{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Notes:\n",
    " * revised and tuned configuration, updated views\n",
    " * training on full dataset (including Y3, new light curves, fixes)\n",
    " * trained with updated star radius estimations, multiple duplicates removed\n",
    " * removed instar examples"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['/mnt/tess/astronet/checkpoints/revised_tuned_35-y2_run_1/1/AstroCNNModel_revised_tuned_20220322_201438',\n",
       " '/mnt/tess/astronet/checkpoints/revised_tuned_35-y2_run_1/2/AstroCNNModel_revised_tuned_20220322_202117',\n",
       " '/mnt/tess/astronet/checkpoints/revised_tuned_35-y2_run_1/3/AstroCNNModel_revised_tuned_20220322_202722',\n",
       " '/mnt/tess/astronet/checkpoints/revised_tuned_35-y2_run_1/4/AstroCNNModel_revised_tuned_20220322_203325',\n",
       " '/mnt/tess/astronet/checkpoints/revised_tuned_35-y2_run_1/5/AstroCNNModel_revised_tuned_20220322_203926',\n",
       " '/mnt/tess/astronet/checkpoints/revised_tuned_35-y2_run_1/6/AstroCNNModel_revised_tuned_20220322_204526',\n",
       " '/mnt/tess/astronet/checkpoints/revised_tuned_35-y2_run_1/7/AstroCNNModel_revised_tuned_20220322_205128',\n",
       " '/mnt/tess/astronet/checkpoints/revised_tuned_35-y2_run_1/8/AstroCNNModel_revised_tuned_20220322_205730',\n",
       " '/mnt/tess/astronet/checkpoints/revised_tuned_35-y2_run_1/9/AstroCNNModel_revised_tuned_20220322_210330',\n",
       " '/mnt/tess/astronet/checkpoints/revised_tuned_35-y2_run_1/10/AstroCNNModel_revised_tuned_20220322_210931']"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import os\n",
    "\n",
    "chkpt_root = '/mnt/tess/astronet/checkpoints/revised_tuned_35-y2_run_1'\n",
    "data_files = '/mnt/tess/astronet/tfrecords-35-y2-val/*'\n",
    "tces_file = '/mnt/tess/astronet/tces-v12-y2-val.csv'\n",
    "\n",
    "nruns = 10\n",
    "\n",
    "def load_ensemble(chkpt_root, nruns):\n",
    "    checkpts = []\n",
    "    for i in range(nruns):\n",
    "        parent = os.path.join(chkpt_root, str(i + 1))\n",
    "        if not os.path.exists(parent):\n",
    "            break\n",
    "        all_dirs = os.listdir(parent)\n",
    "        if not all_dirs:\n",
    "            break\n",
    "        d, = all_dirs\n",
    "        checkpts.append(os.path.join(parent, d))\n",
    "    return checkpts\n",
    "\n",
    "paths = load_ensemble(chkpt_root, nruns)\n",
    "paths"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Running model 1\n",
      "2205 records\n",
      "Running model 2\n",
      "2205 records\n",
      "Running model 3\n",
      "2205 records\n",
      "Running model 4\n",
      "2205 records\n",
      "Running model 5\n",
      "2205 records\n",
      "Running model 6\n",
      "2205 records\n",
      "Running model 7\n",
      "2205 records\n",
      "Running model 8\n",
      "2205 records\n",
      "Running model 9\n",
      "2205 records\n",
      "Running model 10\n",
      "2205 records\n"
     ]
    }
   ],
   "source": [
    "import getpass\n",
    "import os\n",
    "from astronet import predict\n",
    "import tensorflow as tf\n",
    "\n",
    "\n",
    "def run_predictions(path):\n",
    "    predict.FLAGS = predict.parser.parse_args([\n",
    "      '--model_dir', path,\n",
    "      '--data_files', data_files,\n",
    "      '--output_file', '',\n",
    "    ])\n",
    "\n",
    "    return predict.predict()\n",
    "\n",
    "\n",
    "paths = load_ensemble(chkpt_root, nruns)\n",
    "ensemble_preds = []\n",
    "config = None\n",
    "for i, path in enumerate(paths):\n",
    "    print(f'Running model {i + 1}')\n",
    "    preds, config = run_predictions(path)\n",
    "    ensemble_preds.append(preds.set_index('tic_id'))\n",
    "    print()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "labels = ['disp_e', 'disp_n', 'disp_j', 'disp_s', 'disp_b']\n",
    "\n",
    "col_e = labels.index('disp_e')\n",
    "thresh = 0.2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "scrolled": false
   },
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import pandas as pd\n",
    "\n",
    "agg_preds = {}\n",
    "\n",
    "for preds in ensemble_preds:\n",
    "    for tic_id in preds.index:\n",
    "        if tic_id not in agg_preds:\n",
    "            agg_preds[tic_id] = []\n",
    "\n",
    "        row = preds[preds.index == tic_id]\n",
    "        pred_v = row.values[0]\n",
    "        if len(row.values) > 1:\n",
    "            print(f'Warning: duplicate predictions for {tic_id}')\n",
    "        if pred_v[col_e] >= thresh:\n",
    "            agg_preds[tic_id].append('disp_e')\n",
    "        else:\n",
    "            masked_v = [v if i != col_e else 0 for i, v in enumerate(pred_v)]\n",
    "            agg_preds[tic_id].append(preds.columns[np.argmax(masked_v)])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "final_preds = []\n",
    "for tic_id in list(agg_preds.keys()):\n",
    "    counts = {l: 0 for l in labels}\n",
    "    for e in agg_preds[tic_id]:\n",
    "        counts[e] += 1\n",
    "    maxcount = max(counts.values())\n",
    "    counts.update({\n",
    "        'tic_id': tic_id,\n",
    "        'maxcount': maxcount,\n",
    "    })\n",
    "    final_preds.append(counts)\n",
    "    \n",
    "final_preds = pd.DataFrame(final_preds).set_index('tic_id')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "tce_table = pd.read_csv(tces_file, header=0).set_index('tic_id')\n",
    "for l in labels:\n",
    "    tce_table[l] = tce_table[l[:-1] + l[-1].upper()]\n",
    "tce_labels = tce_table[labels]\n",
    "\n",
    "pl = final_preds.join(tce_labels, on='tic_id', how='left', lsuffix='_p')\n",
    "\n",
    "pl.head()\n",
    "pd.set_option('display.max_columns', None)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Recall: 0.982532751091703\n",
      "Precision: 0.7009345794392523\n"
     ]
    }
   ],
   "source": [
    "ppos = (pl['disp_e_p'] > 0)\n",
    "pos = (pl['disp_e'] > 0)\n",
    "\n",
    "pneg = (pl['disp_e_p'] == 0)\n",
    "neg = (pl['disp_e'] == 0)\n",
    "\n",
    "print('Recall:', len(pl[ppos & pos]) / len(pl[pos]))\n",
    "print('Precision:', len(pl[ppos & pos]) / len(pl[ppos]))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "393324927\n",
      "104485403\n",
      "199661915\n",
      "141753278\n"
     ]
    }
   ],
   "source": [
    "for i in pl[pos & pneg][[]].join(tce_table, on='tic_id', how='left').index:\n",
    "    print(i)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "283330382\n",
      "14209654\n",
      "16740282\n",
      "188258751\n",
      "199376584\n",
      "202685576\n",
      "356776209\n",
      "416282321\n",
      "43306175\n",
      "136651206\n",
      "138078677\n",
      "277848886\n",
      "278555119\n",
      "395986110\n",
      "417208086\n",
      "252588526\n",
      "431338538\n",
      "116498176\n",
      "192591652\n",
      "240833511\n",
      "332870317\n",
      "450006142\n",
      "94280922\n",
      "127846210\n",
      "261814771\n",
      "269291226\n",
      "164528404\n",
      "279980795\n",
      "405687343\n",
      "308805406\n",
      "390929238\n",
      "408945155\n",
      "428942240\n",
      "55244346\n",
      "648359612\n",
      "82242456\n",
      "142615793\n",
      "142751024\n",
      "56861756\n",
      "91987762\n",
      "138847344\n",
      "165373714\n",
      "154271808\n",
      "159636125\n",
      "219824182\n",
      "230197530\n",
      "284266496\n",
      "298647682\n",
      "118139893\n",
      "118398402\n",
      "141979739\n",
      "149060376\n",
      "161030195\n",
      "177385907\n",
      "183076970\n",
      "201601338\n",
      "21601170\n",
      "260659602\n",
      "261205462\n",
      "271999852\n",
      "276738707\n",
      "278632192\n",
      "281578420\n",
      "287722370\n",
      "290289095\n",
      "291374558\n",
      "293328926\n",
      "293527927\n",
      "30275847\n",
      "30407196\n",
      "309650507\n",
      "311103813\n",
      "314828080\n",
      "31868634\n",
      "319865847\n",
      "320356995\n",
      "322284262\n",
      "325279192\n",
      "326693475\n",
      "339601581\n",
      "344128598\n",
      "363404187\n",
      "373919592\n",
      "379191982\n",
      "384740598\n",
      "38570890\n",
      "404851552\n",
      "404851966\n",
      "404934011\n",
      "40602499\n",
      "406091286\n",
      "407615704\n",
      "41256189\n",
      "419611478\n",
      "446698252\n",
      "109851914\n"
     ]
    }
   ],
   "source": [
    "for i in pl[neg & ppos][[]].join(tce_table, on='tic_id', how='left').index:\n",
    "    print(i)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>disp_e</th>\n",
       "      <th>disp_n</th>\n",
       "      <th>disp_j</th>\n",
       "      <th>disp_s</th>\n",
       "      <th>disp_b</th>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>tic_id</th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "Empty DataFrame\n",
       "Columns: [disp_e, disp_n, disp_j, disp_s, disp_b]\n",
       "Index: []"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def compare(ensemble_preds, filter):\n",
    "    result = ensemble_preds[0][filter]\n",
    "    for preds in ensemble_preds[1:]:\n",
    "        result = result.append(preds[filter])\n",
    "    return result\n",
    "\n",
    "compare(ensemble_preds, preds.index == 340066802)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>disp_e_p</th>\n",
       "      <th>disp_n_p</th>\n",
       "      <th>disp_j_p</th>\n",
       "      <th>disp_s_p</th>\n",
       "      <th>disp_b_p</th>\n",
       "      <th>maxcount</th>\n",
       "      <th>disp_e</th>\n",
       "      <th>disp_n</th>\n",
       "      <th>disp_j</th>\n",
       "      <th>disp_s</th>\n",
       "      <th>disp_b</th>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>tic_id</th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "Empty DataFrame\n",
       "Columns: [disp_e_p, disp_n_p, disp_j_p, disp_s_p, disp_b_p, maxcount, disp_e, disp_n, disp_j, disp_s, disp_b]\n",
       "Index: []"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "pl[pl.index == 340066802]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### PR curve"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "tics = set(ensemble_preds[0].index.values)\n",
    "\n",
    "tic_index = {v: i for i, v in enumerate(tics)}\n",
    "\n",
    "pred_es = np.zeros([len(ensemble_preds), len(tic_index)])\n",
    "for i, preds in enumerate(ensemble_preds):\n",
    "    for row in preds.iterrows():\n",
    "        tic, pred_e = row[0], row[1][col_e]\n",
    "        pred_es[i][tic_index[tic]] = pred_e\n",
    "\n",
    "lbl_es = np.zeros([len(tic_index)], dtype=np.bool)\n",
    "for row in tce_labels.iterrows():\n",
    "    tic, lbl_e = row[0], row[1]['disp_e']\n",
    "    if tic in tic_index:\n",
    "        lbl_es[tic_index[tic]] = (lbl_e > 0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "num_cond_pos = int(np.sum(lbl_es))\n",
    "\n",
    "def pr_at_th(th):\n",
    "    pred_pos = np.any(pred_es >= th, axis=0)\n",
    "    true_pos = pred_pos & lbl_es\n",
    "    num_pred_pos = int(np.sum(pred_pos))\n",
    "    num_true_pos = int(np.sum(true_pos))\n",
    "    if num_pred_pos == 0:\n",
    "        return 1.0, 0.0\n",
    "    return float(num_true_pos) / float(num_pred_pos), float(num_true_pos) / float(num_cond_pos)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "AUC: 0.9720156823382539, max R: 1.0, max P: 1.0\n",
      "100% recall at: 48%, threshold: 0.04149630451207853\n"
     ]
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAABD0AAAKuCAYAAACi1mevAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAAewgAAHsIBbtB1PgAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4xLjMsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+AADFEAAAgAElEQVR4nOzdeXhcZ333/889+4wky7vjfYnt2LEdr0nsOBuF9tcmLIFSSgulpSS0tLRA2qctpQEChQJlX/q0DWuhBdqnBUrDkoU0ZIOE2E6cOIrtxHYc74tsSTOa0Sz3748Z2SNptFpnzujc79d1zTVHc+6Z89XMR8fyV+ec21hrBQAAAAAAEDQhvwsAAAAAAADwAk0PAAAAAAAQSDQ9AAAAAABAINH0AAAAAAAAgUTTAwAAAAAABBJNDwAAAAAAEEg0PQAAAAAAQCDR9AAAAAAAAIFE0wMAAAAAAAQSTQ8AAAAAABBIND0AAAAAAEAg0fQAAAAAAACBRNMDAAAAAAAEEk0PAAAAAAAQSDQ9AAAAAABAINH0AAAAAAAAgUTTAwAAAAAABBJNDwAAAAAAEEg0PQAAAAAAQCDR9AAAAAAAAIHkbNPDGDPTGPNyY8wHjDE/NMacNMbYyu2rHm3zt4wxdxljjhpjssaYA8aYbxhjtnixPQAAAAAAXGastX7X4AtjzFDf+Nestb83jttKSvp/km4YZEhJ0gestbeP1zYBAAAAAHCds0d69POCpLs8fP0v63zD4z5JN0m6QtJbJD2n8ufwfmPMWz2sAQAAAAAAp7h8pMftkh6T9Ji19pgxZpGkfZXV43akhzHmlyTdW/ny+5Jeba0tVq2fLulxSQsknZG0xFrbPh7bBgAAAADAZc4e6WGtfZ+19n+stcc83tSfV+4Lkv6ouuFRqeOkpL+sfDlZ0s0e1wMAAAAAgBOcbXrUgzGmRdJLK1/eY619cZCh/yWpo7L8as8LAwAAAADAATQ9vHW5pFhl+f7BBllreyT9rPc5xpio14UBAAAAABB0Eb8LCLhLq5bbhhnbJulXVP5MlknaNdyL33777XFJayTNlHRKUnHoZ+jocK8JAAAAAMAQwpJmVJZ3vu9978v5WcxwaHp4a17V8mCntvQ6WLU8XyNoeqjc8HhstEUBAAAAADAOLpf0C7+LGAqnt3irpWq5a5ix6arlZg9qAQAAAADAKRzp4a1E1XLPMGOrDwlKjvD1T/QuvOpVr9J77jqifaezI60NAAAAGFfLZ6b0xivmyUgqWStjjKKxuCSrbDYna62sJCsra6VINKZQKKR8Pq98oSjZ8+tC4ZAi4aiKtqSeXI9KlXVlRrFYVFZSrqdHpVL5OedeNxJVyBgVikXlC4Vz62QlEwopHInIlqxy+Z4+27SSIpGYrKzy+Xx5m1ZS73PDIRkTUqlUUr5YrrcpFtJ1y6bp4pktSiaTstYqnU4PeG9SqZRCoZCy2awKhUKfdbFYTLFYTIVCQdls39/nQ6GQUqmUJCmdTsta22d9MplUOByu+brRaFTxeFzFYlHd3d191hlj1NTUJEnKZDIqlUp91icSCUUiEeVyOeXz+T7rIpGIEomESqWSMpnMgO+1ubn8N9zu7m4Vi33PwI/H44pGo+rp6VFPT9//IoXD4Qt+D/P5vHK5vmdbVL+HXV0D/xY9kvew1mdT/R7W+mxG8h7W+myk8+9hrc9mqPdwuM+mqalJxpian81Q72HvZyNJR48e1Te/+c3eVSfU4Gh6eKv6pyI26KiyeNXywNTXdi6ls2fP1k2bJ+lYB00PBE++UNCZM+2aPHmKohF2Wwgmcg4XkPNg6cjm9R+Pv6jq/+ftOF7Qjv/Z71tNfvnXJ87oR++8RrMmpZTJZHTy5EktXbr03H+0q02aNGnM2xnqucO97pQpU8b83KFMnjzZk9dtbW315HUv5D0c6+sOZ6J9Nv0Md11J3/Gvjbc6q5aHO2WlqWp5uFNhBigWi7rl2iWjfRowIXR2dmrbtnZt2LBYLS0twz8BmIDIOVxAzoPn11bP1p9+c7s6c4XhBwdYV66gh/ee0usuT6lYLKq9vX3AX9EB+INrenir+uKl8wYdVTa/avngoKMAAACABvGSFTP1nT/eqsXTm4YfHHDZAk0OoBFxpIe3qmdgWTHM2N71BUl7vCkHAAAAGF9LZzbru3+0VR/6wS79fN9pFUtWxkghY2RUvu6BkSSjc1+HjGRkZEz5Ncy5sZXnVcaq6vH+zz3/eudfq/e5/V/TqHqdqXq98nNDof6v2a+ec/Wff+59z57Qya6GnqkTgGh6eO0xlS9gGpN0naSP1BpkjIlJ2tz7HGttvtY4AAAAoBG1pqL62GvX+l1GXf3mPz1C0wOYAGh6eMha22mMuVfSr0l6mTFmnrX2xRpDXyOp90oy3xnLtmKx4a6TCkxc8XhcS5cuVTweH34wMEGRc7iAnCPIvv/EYT1zpFP5QkGZ7pj+6/AeyRgVS1Yla1UsWRVLqlqu3KxVqeo+FDK6cvE03frLyxWLcDUC4ELR9LgAxpjfk/SVype3W2vfX2PYx1VuekQkfcEY8xpr7bkT/owx0yV9tPLlGUlfHEstND0QZLFYTHPnzvW7DMBT5BwuIOcIssf2t+ux/e3j8lrbXzijZDSsd7xs2bi8HuAyZ5sexpirJS2temh61fLSSkPjHGvtV8eyHWvtT4wx35L0ekmvlHS3MebTkg5LWiPpPZIWVIb/pbV2THvK/vM+A0GSz+d1+vRpTZ06VdFo1O9yAE+Qc7iAnCNIvD4KY9sL49NAAVznbNND0s2SfneQdVsrt2pfvYBt/b7Kp6/cIOkllVu1kqQPWmv/eawbyOU4nxDBlc1m1dbWpg0bNvBLMgKLnMMF5BxB8rKVs/TAnpOevf79u09oxW0/VMlKS6Y36VdXX6Qb18zWsllM9wyMhstNj7qx1nZLutEY89uSfk/SWkmTJR2T9ICkz1trH/GvQgAAAACj8aYtC9WajOrR/adlrRQOSWFjVCwUdPLEcc2+aJYSibjCxigUMgobo3BIVctGod77kNHXHt6vvce7+mwjmy9JktqOdqrtaKc+fc8eLZ3ZrBvWzNaNa2Zr+axmmd7pagDU5GzTw1r7eyo3IC7kNb6qURwBYq39N0n/diHbBAAAAOA/Y4xuWj9XN63ve52azs5Obdt2Vhs2LFFLy8iPypiUiOgd39ox7Li9x7v02Xv36LP37tHFM5p0w5rZWjO3VcWSVaFkVSiVVCj2LlsViiUVS1b5olWxVFK+WBlTsioUbWVd3zEzWuJ64+aFWjitadTvC9BonG16AAAAAECj+KUVM7V67iQ9dahjxM957kRan/vJXk/q+f4TR/TAX75E0TAzyGBio+kREOFw2O8SAM+Ew2G1tLSQcwQaOYcLyDlcMNactySi+u4fbVXb0U5154sKGaNIyKgrV9A9zxzTD3ce1dGOrEdVD3S0I6tnj3Zq5exJChlxGg0mLJoeAZFMJv0uAfBMKpXShg0b/C4D8BQ5hwvIOVxwITmPhENaPbd1wONbl07XbTdequ0H2/WDnUf1w51HdPis9w2Ql3/uQUlSazKqP7r+Yv3BdRd7vk1gvNH0AAAAAIAGFwoZbVw4VRsXTtV7blipHS+e0Q93HtEDe04q01NUJFw+MiQSCg1YDoeMouFQ5d4oHAopGjKVdaHKY0ZfeWh/zW2f7c7r737Yphsvm615U1L1/caBC0TTIyC6uro0adIkv8sAPFG+INg2bdiwYVQXBAMmEnIOF5BzuKAeOQ+FjDYsmKINC6aM6+ve13Zc+09lBl3/wf/Zpc1LpilfLF8QtadQUr5YUlM8ohvWzNbi6Vz4FI2HpgcAAAAAQO982XLd+u87VLK11//46WP68dPHaq77558+r7vfda1mTkp4WCEwejQ9AAAAAAC6af1cXX/JDO07mVYkFNIrPv/giJ97tjuvh587pVeunaOeYvkIkPKRIOUjQnoqX/cUS4qEjC65qIWZYVAXND0AAAAAAJKkyamY1i+ISZJuWHORfrDz6Iif+85v79A7v71jRGPnT03q3/9gi2a3MiEDvEXTAwAAAAAwwIduWqNULKJnjnQoEg4pFi5fELX3ds8ztU91GYmDp7v1n4+/qLf/0rJxrBgYiKZHQKRSXEUZwdXU1KQrrrhC8Xjc71IAz5BzuICcwwVByvmUppg+/htrB13/h19/XD96euRHgvT38bt26/7dJ2SM0XXLZ+ht112sUMiM+fWAWmh6BEQoxPlwCK5QKKRkkkMfEWzkHC4g53CBSzm/5drF+umeE8r0FMf8Go/tb5ckPbrvtCanonrDlQvHqzxAEk2PwMhms0xZi8Dq7u7W/v37tWjRImd+iYB7yDlcQM7hApdyvnHhVD36npfp2aMdCpnyqS/xSPnUl1jVfe9jH/tRm/7pp88P+nqPH2in6YFxx+EBAVEoFPwuAfBMoVDQ8ePHyTkCjZzDBeQcLnAt583xiDYunKr1C6Zo9dxWLZvVokXTmzRnclIzWuJqTUaViIYVDhn96uqLFBtixpbSYHPlAheAIz0AAAAAAJ5bv2CKvvf2rXpgzwkVS9JPd5/QI8+fGvI51lr1FEvK5kvKFYrK5cvT4S6YmlKEKW8xAjQ9AAAAAAB1sXL2JK2cXT4tvyOb79P0uOeZ47r2Y/cpVyieb3IUSrI1DgBpTUb1lTdfrg0LptSrdExQtMYAAAAAAL7ryhX0wumMjnXkdLY7r2y+dsNDks525/XZe/fUt0BMSDQ9AiIajfpdAuCZWCymhQsXKhaL+V0K4BlyDheQc7iAnI9cS+LCTjw4ciY7TpUgyGh6BEQQ5gEHBhOPx7Vo0SJyjkAj53ABOYcLyPnI3bB6tqak+OMtvMU1PQLClatDw02FQkEdHR2aNGmSIhF2Wwgmcg4XkHO4gJyP3KLpTfrRO6/VI8+dUqFkFY+ElIiGa97HoyHd13ZCf/2dnX6XjQmGn8KAyGY5tAvB1d3drZ07d2rDhg1qaWnxuxzAE+QcLiDncAE5H51ZkxK6af3cEY1tvsDTYeAmTm8BAAAAAExIhWJJ6RxHvWNwtMoAAAAAABPOs8c6tfQ9P5QkzZuS1P99w0atmdfqc1VoNBzpAQAAAACY0F5s79aHf/DMgMettcoXSz5UhEbBkR4BEQrRv0JwhUIhJRIJco5AI+dwATmHC8i5d6Y3Dz0N8CPPn9KvfvqnyuaLyvQU1d1TVCZfVLFkNac1ob//jbXaunR6napFo+AnMSBSqZTfJQCeaWpq0pVXXqmmpia/SwE8Q87hAnIOF5Bz72xaOFWbl0wdckzb0U7tP5XR8c6cOnMFFUtWknT4bFbvYeYXJ3GkBwAAAACg4cUiIf3rzZvVdrRD6VxRuw6f1fu/v2vEz99/KqOXffJ+ZfNFzZ2c1G0vv1Sr53INkKDjSI+ASKfTfpcAeKarq0sPP/ywurq6/C4F8Aw5hwvIOVxAzr0VDhmtmtOqKxZP1W9fuVAXzxjdETV7j3fpxfZu/Xzfaf3hNx6XtdajStEoONIjIPhhRZBZa5XP58k5Ao2cwwXkHC4g5/UTi4T0n2+7SnftOqaO7rySsbBSsbCS0YhSsbDOduf1J9/cPujzX2zvVkd3Qa2paB2rRr3R9AAAAAAATEiTUzG9btP8Qdd/+7GDenDvyUHXW42uOVUqWWXyRUXDRvFIeFTPhT9oegAAAAAAAumON23SvW3HdKwjp2KppA//oK3P+m/87ICsldI9RWV6CkrnKvc9RWVy5ft0rnBuXXe+KEmKhUN605aFes+NK2WM8eNbwwjR9AAAAAAABFIyFtbLL5sjSTrekR3Q9Pj4XbvH9Lo9xZK++OA+vXbTPK24aNIF1wnvcCHTgEgmk36XAHgmlUpp3bp1TM2MQCPncAE5hwvIeQPz4ICMA6cy4/+iGFc0PQIiHOZ8MgRXOBxWa2srOUegkXO4gJzDBeS8cc1ojmt2a8LvMlBnnN4SELlczu8SAM/kcjkdPHhQ8+fPVzwe97scwBPkHC4g53ABOW9cxhjd8aZN+tiPn9WRM91qikfUFA8rFYuoKRZWKl65j1U9XrlvjpdnhPnjf92mw2ezfn8rGAWaHgGRz+f9LgHwTE9Pjw4dOqRZs2bxywMCi5zDBeQcLiDnjW313Fb9y+9fMebnx6N9j+D5zD17ZCS9bOUshUJc0LQRcXoLAAAAAAAjkIr1bXrsOtKht379cd3w2Qf06L7TPlWFodD0AAAAAABgBF61bk7Nx9uOduqNX/y5Dp3prnNFGA5NDwAAAAAARuCWa5bok69bq4XTBs7O01Ms6TGO9mg4ND0CIhLh8iwIrmg0qjlz5igajfpdCuAZcg4XkHO4gJwHmzFGr9kwT/feep0+/Zvr1Jrs+znniyWfKsNgaHoERCLB1EsIrkQioWXLlpFzBBo5hwvIOVxAzt0QCYd00/q5NY/4QGOh6REQxWLR7xIAzxSLRXV2dpJzBBo5hwvIOVxAzoHGQtMjILq7uWAOgiuTyWjbtm3KZDJ+lwJ4hpzDBeQcLiDnQGOh6QEAAAAAAAKJpgcAAAAAAAgkmh4AAAAAACCQaHoEhDHG7xIAzxhjFA6HyTkCjZzDBeQcLiDnQGOJ+F0AxkdTU5PfJQCeaW5u1tVXX+13GYCnyDlcQM7hAnIONBaO9AAAAAAAAIFE0yMgmBILQZZOp/XYY48pnU77XQrgGXIOF5BzuICcA42FpkdAlEolv0sAPFMqlZTJZMg5Ao2cwwXkHC4g50BjoekBAAAAAAACiaYHAAAAAAAIJJoeAAAAAAAgkGh6BEQikfC7BMAzyWRSq1atUjKZ9LsUwDPkHC4g53ABOQcaS8TvAjA+IhE+SgRXJBLR9OnT/S4D8BQ5hwvIOVxAzoHGwpEeAdHT0+N3CYBnenp69MILL5BzBBo5hwvIOVxAzoHGQtMjINipIshyuZz27dunXC7ndymAZ8g5XEDO4QJyDjQWmh4AAAAAACCQaHoAAAAAAIBA4uqXAAAAAACMg+OdOW17oV2RkNElF7UoHgn7XZLzaHoEBLO3IMh6r4JOzhFk5BwuIOdwATl329//+Nlzy6vmTNK33rpZLYmojxWB01sCIpFI+F0C4Bnmu4cLyDlcQM7hAnKOXk8f7tBP2o77XYbzaHoERKlU8rsEwDOlUkm5XI6cI9DIOVxAzuECcu6WiyYN/cfnk13Msuk3mh4Bkclk/C4B8Ew6ndbPfvYzpdNpv0sBPEPO4QJyDheQc7e87fqLNSnBqUyNjE8HAAAAAIAxWL9gih77m5fp4OluNcXDeue3dujn+077XRaq0PQAAAAAAGCM4pGwls5sliRFw5xM0Wj4RAAAAAAAQCDR9AAAAAAAAIHE6S0B0dTU5HcJgGeam5t1zTXXyBjjdymAZ8g5XEDO4QJyDjQWmh4BwU4VQWaMIeMIPHIOF5BzuICcA42F01sCoru72+8SAM9kMhnt2LGDqZkRaOQcLiDncAE5BxoLTY+AKBaLfpcAeKZYLOrs2bPkHIFGzuECcg4XkHOgsdD0AAAAAAAAgUTTAwAAAAAABBJNDwAAAAAAEEg0PQIiHo/7XQLgmUQioeXLlyuRSPhdCuAZcg4XkHO4gJwDjYUpawMiGo36XQLgmWg0qtmzZ/tdBuApcg4XkHO4gJyj2k/ajum5E13KF0paO3+yblwzW1OaYn6X5RSaHgGRz+f9LgHwTD6f18mTJzV9+nQafAgscg4XkHO4gJyj2kN7T+mhvackSf/x+Iu6/ftP67rlM/SqdXP1y5fOUiIa9rnC4OP0loDI5XJ+lwB4JpvNavfu3cpms36XAniGnMMF5BwuIOduM2bo9fmi1T3PHNeffHO7bvrCQzrRyf/jvMaRHgAAAAAAjIPL5rXqgT0nRzS27WinLv/QPbr+khnqKZR07fIZ+oNrl8gM1znBqND0AAAAAABgHPzJLy3T2e68Hj9wRs3xsKY1xTW9Jab2dF73PHNMuUJpwHP+99kTkqSHnzulqU0xvW7T/HqXHWg0PQAAAAAAGAeJaFh/e9Oamus6s3lt+tt7ajY+ej2+v52mxzjjmh4BEQ5zARwEVzgcVmtrKzlHoJFzuICcwwXkHINpSUT197+xdsgxRWvrVI07ONIjIJLJpN8lAJ5JpVJat26d32UAniLncAE5hwvIOYbyistmqzOb1/3PnlAsEtLe411qO9rpd1mBRtMjICwdQQSYtVbWWhljuLATAoucwwXkHC4g5xiKMUZvuHKh3nDlQknSh+7cRdPDY5zeEhDpdNrvEgDPdHV16YEHHlBXV5ffpQCeIedwATmHC8g50FhoegAAAAAAgECi6QEAAAAAAAKJpgcAAAAAAAgkmh4AAAAAACCQaHpIMsYsNMZ8whjTZoxJG2NOG2MeM8b8H2NMapy2scgY81FjzOPGmDPGmHxlOw8bY95rjJl5Ia+fSo1LmUBDampq0ubNm9XU1OR3KYBnyDlcQM7hAnIONBbnp6w1xrxC0jckTap6OCVpU+V2szHmRmvt3gvYxu9I+idJyX6rpkjaUrm9wxjzemvt3WPZRihE/wrBFQqFFI/H/S4D8BQ5hwvIOVxAzoHG4vT/lI0x6yV9W+WGR5ek90i6StJLJd1RGbZc0p3GmJYxbmOrpK+q3PAoSfqKpJskXSHptZK+Xxk6VdL3jDFLxrKdbDY7lqcBE0J3d7eefvppdXd3+10K4BlyDheQc7iAnAONxemmh6TPqNyMKEj6FWvth621j1hrf2Ktfaukv6iMWy7pz8a4jXfr/Pv8J9ba37fWfs9a+5i19j+tta+U9MnK+qSkW8eykUKhMMbygMZXKBR08uRJco5AI+dwATmHC8g50FicbXoYY66QdE3lyy9Zax+pMewTkp6pLL/DGBMdw6auqtyfstb+wyBjPlC1vGUM2wAAAAAAAP042/RQ+RSTXl+pNcBaW5L0L5UvJ0t6yRi2E6vc7xtsgLX2rKST/cYDAAAAAIAL4HLT4+rKfVrS40OMu79qeesYtvNs5X7xYAOMMZMkTe83HgAAAAAAXACXZ29ZWbnfa60d6oS7thrPGY1/lPTPkqYZY/7QWvuPNcbc1m/8qPX09Kijo2PIMZMmTRpyPdCo4vG4Fi9ezJXQEWjkHC4g53ABOQcai5NND2NMQuePrHhxqLHW2nZjTFpSk6T5Y9jcl1U+quRNkr5gjNko6b8lHZG0QNLv6PypNh+y1t4zhm3oa1/72rBjbr31/DVSW1rKk9FkMhkVi8U+4xKJhKLRqHp6epTL5fqsC4fDSqVSstaqq6trwDaampoUCoXU3d094OJN8XhcsVhM+Xx+wGwzoVDo3FzmnZ2dA143lUopHA4rm80qn8/3WReLxRSPx1UoFAZcJdsYo+bmZklSV1eXrLV91ieTSUUiEeVyOfX09PRZF41GlUgkVCwWlclkBtTU+x6m02mVSqU+64Z6DyORiJLJpEqlktLp9IDXbW5uljGm5mcz1HvY+9lItd/DoT6bod7D6s+m1nvY+9mM9j2s/mxqvYe9n03vezhlyhTlcjnlcrkLeg97P5uh3sMLyfeFvIdD5ftC3sNan81w7yH7iLJ67yOmTJly7v1mHzG6fUQ19hFljbqPWLBggay1o84h+4gyfo8oa+R9RDQa7fN7y0jeQ/YRZS7+HlHq95x8Pq/Ozs6G3kfU+mwamZNND0nV08+O5BPrbXo0j3ZD1tqipN81xnxf0l9Lurlyq3afpA+PteExUtu2bTu3fN1110mS2traBvzgr1ixQrNmzdKJEye0d+/ePuumTJmiyy67TMVisc/r9dqyZYtisZiee+45nTp1qs+6JUuWaP78+Tpz5ox27drVZ11zc7M2btwoSdq+ffuAHcamTZvU1NSkAwcO6OjRo33WzZ8/X0uWLFFXV5eeeOKJPutisZi2bClfG3bnzp0DdjZr167V5MmTdejQIR08eLDPuosuukiXXHKJstnsgO/VGKNrr71WUvk97P+Df+mll2rGjBk6duyYnn/++T7rpk2bptWrV6tQKNR8D7du3apIJKK9e/eqvb29z7qlS5dq7ty5On36tNra2vqsa2lp0YYNGySp5uteccUVSiaT2r9/v44fP95n3cKFC7Vo0SJ1dHRo586dfdYlEgldeeWVkqQnn3xywD8E69atU2trqw4ePKhDhw71WTdnzhwtW7ZMmUxmQE3hcFhXX10+y2zXrl0D/iFetWqVpk+frqNHj2rfvr6XxJk+fbpWrVqlfD5f83u95pprZIzR7t27dfbs2T7rli9frtmzZ+vkyZPavXt3n3Wtra1at26drLU1X3fz5s2Kx+N6/vnndfLkyT7rFi9erAULFujMmTN6+umn+6xLpVK6/PLLJUk7duwY8A/Mhg0b1NLSooMHD+rw4cN91s2dO1dLly5VV1eXduzY0WddNBrVVVeVr5X81FNPDfjHac2aNZo6daqOHDmiAwcO9Fk3c+ZMrVy5Urlcrub3yj6izI99RO97yD6CfUSvIO0jJk+erLlz56q5uZl9BL9HSArmPmKw12UfUcbvEWW9+4hiv+bNqVOntH379obeR/T/OW90pv8H7gJjzHxJL1S+/Lq19k3DjH9B5aM8nrPWLh3D9lZK+qikX1PtRlNW0ncl/bm19lCN9TXdfvvt8yQdlKRXv/rVmj59+rl1kUik3Dkslc79I9DbLaxepvvKX2ikxv8LTXt7u9ra2rRixQqlUin+ijvK95C/0EyMfUQmk1FbW9u5X9TZRzTuX3HZR4x9H5HNZrVr1y6tX79expgBr8s+oozfI8om6j6io6ND27dvP/d7y0jeQ/YRZS7+HvHB/3laX3pw/7nHX3XZLP3tKy5p6H3E4cOHdccdd/Sumv++971vyLMn/OZq02OGpN4W9betta8fZvwxSTMlPWWtXTPKbV0j6fuSWiUdkPQ3ku6WdFrSLEmvlPRBSVMlHZb0K9bap2u/Wl/VTY9bbrlFc+bMGU1pwITR2dmpbdu2nftLBhBE5BwuIOdwATnHaHzozl2644HzRyO9duM8ffw31vpY0fA6Ojr0qU99qvfLhm96uHp6S3V7bySnrDRV7kd18pIxJi7pm7ISj+MAACAASURBVCo3PI5K2mytrT5e6kVJ/2CMuV/SLyTNkfQ1SZtGsx0AAAAAADCQk1PWWmuzknpPAps31FhjzBSdb3ocHGpsDb8qaW5l+XP9Gh7V9Twt6RuVLzcaYxq7tQcAAAAAwATgZNOjovfqNkuNMUMd8bKiavmZUW6jeorbgVeR6evxQbY5IqGQyx8lgi4UCimVSpFzBBo5hwvIOVxAzoHG4urpLZL0oKRrVD6KY6Oknw8y7rqq5YdGuY3qq+sM915HB3neiFRfJAkImqampnNXLQeCipzDBeQcLiDnQGNxuf343arlN9caYIwJSeqd2eWMylPLjkb1/FjXDDO2urmyb9BRAAAAAABgRJxtelhrH5X0QOXLtxhjttQY9mc6f4rKZ6y1feYvMsZcb4yxldtXazz/Xkm9c0O9zRhTc+YXY8yvSXp15ctDknbUGjeUWtMRAUHR1dWlBx98sObUZUBQkHO4gJzDBeQcaCwun94iSe9Q+ZSVpKS7jDEfVvlojqSk10t6a2XcbkmfGO2LW2vPGGM+IukDklokPWyM+ZzKU9a2qzxl7ask3aLzDai/staWar3eMNsa7VOACcNaq2KxSM4RaOQcLiDncAE5BxqL000Pa+12Y8xvqjxzyiRJH64xbLekG621nTXWjcTfSpqqcoOlWdK7K7f+8pL+2lr7jRrrAAAAAADAKDnd9JAka+33jTGXqdyUuFHlKWx7JO2V9B+SPm+tzQzxEsO9vpX0LmPMNyTdLOlqSQslpSR1VbZzv6R/stbuvpDvBQAAAAAwcT22/7Ru/tpj6swWdOXiqfrTly5TJOzsVSnGhfNND0my1h6QdGvlNprn/a8kM8Kxj6vvtLQAAAAAAJxz4FRGB06V/+b+832nNSkZ1c3XLPG5qomNllFAJJNJv0sAPJNKpbRhwwamZkagkXO4gJzDBeQcoxEyQ/8N/fED7XWqJLg40iMgwuGw3yUAngmHw2ppafG7DMBT5BwuIOdwATnHaKxfMGXI9SUuiHvBONIjILLZrN8lAJ7JZrPas2cPOUegkXO4gJzDBeQco/H/rZql215+qTYvmarrls/QytmT/C4pcDjSIyAKhYLfJQCeyefzOnz4sC666CIlEgm/ywE8Qc7hAnIOF5BzjIYxRm+5erHecvViSdJn792jZ450nFtvrdSe7tHhs906ejarw2ezOnKmW+2ZvFbNmaTfvmKBQqERXWbSWTQ9AAAAAABoQHftOqa7dt096Pr2dI/+5KXL6ljRxMPpLQAAAAAATED3PXtcPYWSjndkVSxx/Y9aONIDAAAAAIAG0JIY3X/Rt71wRpfc9kNZK01JRXXHmzZp06KpHlU3MXGkR0BEo1G/SwA8E4vFNHfuXMViMb9LATxDzuECcg4XkHNciF++dJamNQ3MjjHSzJZ4zef0TvDSnsnrk3fv9rK8CYkjPQIiHq/9AwAEQTwe19KlS/0uA/AUOYcLyDlcQM5xIeZNSel//vRqPfLcKYVDRnMmJzW7NaFZkxKKhkP68dNH9Qdff3zQ57/Y3l3HaicGmh4BUSwW/S4B8EyxWFRXV5eam5sVDof9LgfwBDmHC8g5XEDOcaFmtyb1mg3zaq7bvGSaZrcmdORs7SmRS9bqxfaMTnb1aN6UpKY388dxTm8JiO5uOnoIrkwmox07diiTyfhdCuAZcg4XkHO4gJzDS63JqL73x1v1kdes0d/etFp/dP3Ffda/2N6tqz96n276wkO68sP36ns7DvlUaeOg6QEAAAAAwAQxc1JCr79igd64eaHWL5gy6LhiyeoL9+2tY2WNidNbAAAAAACYgCanhp7QYvexLr3hiz/TsY6c5k5O6v2vXKXF05vqVF1j4EgPAAAAAAAmoHXzJ+uyea1Djnlo7yntPd6l+3ef0K3/vqNOlTUOjvQICGOM3yUAnjHGKBqNknMEGjmHC8g5XEDOUU/RcEjffusWPbb/tHKFko6c7dZ7v/f0oON3vni2jtU1BpoeAdHU5NYhSnBLc3OzrrrqKr/LADxFzuECcg4XkHPUWzIW1rXLZ0iSunuK+ugP25TuqT27p61nYQ2CpgcAAAAAAAGQjIX1b7ds1pcf2qd0rqh4JKQ7dx7xuyxfcU2PgGBKLARZOp3Wz3/+c6XTab9LATxDzuECcg4XkHP4be38yfrM69fri7+7SW//paV91hVLVu/69g791j//TO/41nYdPB38/0dypEdAlEolv0sAPFMqlZTNZsk5Ao2cwwXkHC4g52h039l+6Nzy3uNduvNPr/GxGu9xpAcAAAAAAAE03PV0nz7coe5Brv8RFDQ9AAAAAAAIoCXTm9USH/oEj5IN9uVNaXoAAAAAABBAsUhIX37z5bpm2XRdNq9V1yyb7ndJdcc1PQIikUj4XQLgmWQyqTVr1iiZTPpdCuAZcg4XkHO4gJyj0Vy+aKq+/pYrJUkvtmd09Ufv87mi+qLpERCRCB8lgisSiWjq1Kl+lwF4ipzDBeQcLiDnQGPh9JaAyOVyfpcAeCaXy2n//v3kHIFGzuECcg4XkHOgsdD0CIh8Pu93CYBnenp6dODAAfX09PhdCuAZcg4XkHO4gJwDjYWmBwAAAAAACCSaHgAAAAAAIJBoegAAAAAAgECi6REQzN6CIItEIpo5cyY5R6CRc7iAnMMF5BxoLPwkBkQikfC7BMAzyWRSK1eu9LsMwFPkHC4g53ABOQcaC0d6BESpVPK7BMAzpVJJ3d3d5ByBRs7hAnIOF5BzoLHQ9AiITCbjdwmAZ9LptB599FGl02m/SwE8Q87hAnIOF5BzoLHQ9AAAAAAAAIFE0wMAAAAAAAQSTQ8AAAAAABBIND0AAAAAAEAgMWVtQDQ3N/tdAuCZlpYWXXfddX6XAXiKnMMF5BwuIOdAY+FIDwAAAAAAEEg0PQKiu7vb7xIAz2QyGW3bto2pmRFo5BwuIOdwATkHGgtNj4AoFot+lwB4plgsqrOzk5wj0Mg5XEDO4QJyDjQWmh4AAAAAACCQaHoAAAAAAIBAoukBAAAAAAACiaZHQMTjcb9LADyTSCS0YsUKJRIJv0sBPEPO4QJyDheQc6CxRPwuAOMjGo36XQLgmWg0qlmzZvldBuApcg4XkHO4gJwDjYUjPQKip6fH7xIAz/T09OjQoUPkHIFGzuECcg4XkHOgsdD0CAh2qgiyXC6nvXv3KpfL+V0K4BlyDheQc7iAnAONhaYHAAAAAAAIJJoeAAAAAAAgkGh6AAAAAACAQKLpERDhcNjvEgDPhMNhTZkyhZwj0Mg5XEDO4QJyDjQWpqwNiGQy6XcJgGdSqZQuu+wyv8sAPEXO4QJyDheQc6CxcKRHQFhr/S4B8Iy1VoVCgZwj0Mg5XEDO4QJyDjQWmh4BkU6n/S4B8ExXV5ceeughdXV1+V0K4BlyDheQc7iAnAONhaYHAAAAAAAIJJoeAAAAAAAgkGh6AAAAAACAQKLpAQAAAAAAAokpawMilUr5XQLgmaamJm3ZskWRCLssBBc5hwvIOVxAzoHGwk9iQIRCHLSD4AqFQorFYn6XAXiKnMMF5BwuIOdAY+F/ygGRzWb9LgHwTHd3t5566il1d3f7XQrgGXIOF5BzuICcA42FpkdAFAoFv0sAPFMoFHTq1ClyjkAj53ABOYcLyDnQWGh6AAAAAADgMGut3yV4hmt6AAAAAADgqF/7zAM6crZbrcmYbn/lKt142Wy/SxpXHOkBAAAAAICjXjidUb5odbIrp3f/15MqFEt+lzSuaHoEBFeIRpDF43EtWbJE8Xjc71IAz5BzuICcwwXkHI0sGh66BdCRLehEV65O1dQHTY+AoOmBIIvFYpo/fz45R6CRc7iAnMMF5ByNbGZLXMtnNftdRl3R9AiIfD7vdwmAZ/L5vE6cOEHOEWjkHC4g53ABOUcjM8bo62+5UjdfvViv3ThPb7v+Yr9L8hxNj4DI5YJ1CBJQLZvNateuXcpms36XAniGnMMF5BwuIOdodLMmJfQ3L79UH/+NtTWbHv/yyAF9Z/uL2nW4IxCzujB7CwAAAAAAkCT93/997tzy6zbN08deu9bHai4cR3oAAAAAAOCgeCSkSMgMuv7ff/GiTnRO7LMKaHoAAAAAAOCgeCSsV6+fO+SY9kxPnarxBqe3BEQoRP8KwRUKhdTc3EzOEWjkHC4g53ABOcdE83evWaMb1szWU4fO6vDZbn3z0YN+lzSuaHoERCqV8rsEwDNNTU3auHGj32UAniLncAE5hwvIOSaaSDikl6yYqZesmClJgWt60H4EAAAAAACBRNMjILq6uvwuAfBMZ2enfvrTn6qzs9PvUgDPkHO4gJzDBeQcaCw0PQBMCEGYIxwYDjmHC8g5XEDOgcZB0wMAAAAAAAQSTQ8AAAAAABBIND0AAAAAAEAgMWVtQCSTSb9LADyTSqW0adMmJRIJv0sBPEPO4QJyDheQc6Cx0PQIiHA47HcJgGfC4bCampr8LgPwFDmHC8g5XEDOgcbC6S0Bkc1m/S4B8Ew2m9Wzzz5LzhFo5BwuIOdwATkHGgtNj4AoFAp+lwB4Jp/P6+jRo8rn836XAniGnMMF5BwuIOdAY6HpAQAAAAAAAommBwAAAAAACCSaHgAAAAAAIJBoegRENBr1uwTAM7FYTPPnz1csFvO7FMAz5BwuIOdwATkHGosvU9YaY6ZJ+h1J10paLKlFwzdgrLX2Yo/qWSjpTyXdKGm+pJyk5yT9u6QvWGsz47itl0l6o6SrJc2WVJB0TNKTku6V9HVrbddoXzcej49XiUDDicfjWrJkid9lAJ4i53ABOYcLyDnQWOre9DDGvEbSlyRN6n1ohE+1HtXzCknfqKpHklKSNlVuNxtjbrTW7r3A7UyR9BVJr6qxepKkZZJ+XdIjknaM9vWZvQVBVigU1NXVpebmZkUivvRqAc+Rc7iAnMMF5BxoLHU9vcUYs0nStyS1qtzs6G142GFuXtWzXtK3VW46dEl6j6SrJL1U0h2VYcsl3WmMabmA7bRKulvnGx7fkfQGSZslXS7pNZI+I+nFsW6DecARZN3d3XriiSfU3d3tdymAZ8g5XEDO4QJyDjSWerce/6qyTc8aGaP0GUlJlU8x+RVr7SNV635ijNkj6WMqNz7+TNL7x7idz0naqPJpM6+z1v53v/W/kPQdY8y7JIXHuA0AAAAAAFCl3hcyvVp9Gx5mhLdxZ4y5QtI1lS+/1K/h0esTkp6pLL/DGDPqq4UaY65W+folkvQ3NRoe59gyzlMBAAAAAGAc1LvpMbly39vI+ITK17JolhSx1oaGuI33ERA3VS1/pdYAa21J0r9U1f6SMWzn7ZX7s5I+P4bnAwAAAACAMah30+N45d5Kutta+3+stc9ZazOVBkM9XV25T0t6fIhx91ctbx3NBowxMZ2/jsfd1tps5fGwMWa+MWaRMSYxmtccYlvj8TJAQzLGKBaLkXMEGjmHC8g5XEDOgcZS76bH/Tp/lMfzdd52fysr93uHOaWkrcZzRmqtpN6mxk5jzCRjzKclnZT0gqR9ks4aY+42xlw/ytfuo6mp6UKeDjS05uZmbdmyRc3NzX6XAniGnMMF5BwuIOdAY6n3hUw/J+m3VG58XGeMMdbaul/UtHJ0xfTKl0POmGKtbTfGpCU1SZo/yk1dWrUcUvmCpcv6jYlJepmklxpj3m2t/egotyFJ6uzsHHbMpEmThh0DAAAAAEBQ1LXpYa191BjzEUl/LWmFpC8bY/7cWnuqnnVIqp5+tmsE43ubHqNt106tWv5LlY/6+JGk90p6UuWpcn9d0kdUnsb3I8aYNmvt90a5HX3xi18cdsytt956brmlpfwWZDIZFYvFPuMSiYSi0ah6enqUy+X6rAuHw0qlUrLWqqtr4FvX1NSkUCik7u5uFQp9D6CJx+OKxWLK5/MDptgNhULnjlap1cBJpVIKh8PKZrPK5/N91sViMcXjcRUKhQFTgxljznXZu7q61L/HlkwmFYlElMvl1NPT02ddNBpVIpFQsVhUJpMZUFPve5hOp1Uq9T07a6j3MBKJKJlMqlQqKZ1OD3jd5uZmGWNqfjZDvYe9n41U+z0c6rMZ6j2s/mxqvYe9n81o38Pqz6bWe9j72fT09OjMmTPas2ePli1bdu7xsb6HvZ/NUO/hheT7Qt7DofJ9Ie9hrc9muPeQfURZPfcR3d3d2rNnj1asWKFp06axjxjFPmI897PsI8q82kfkcjnt2bNHq1evHvCaEvuIXvweUTZR9xGdnZ168sknz/3eMpL3kH1EGb9HnOfnPqK/dDqtTOb8PqLWZ9PI6tr0MMa8V1KPytf2mCnpTZJeZ4y5W9IBSUM2P6y1HxinUqqvo9Ez6KjzepOUHHLUQNXnnCQk3S3p5dba3nSdkPSPxpinVD71JyTp74wx/+3FETDbtm07t3zddddJktra2gb84K9YsUKzZs3SiRMntHfv3j7rpkyZossuu0zFYrHP6/XasmWLYrGYnnvuOZ061ffjXLJkiebPn68zZ85o165dfdY1Nzdr48aNkqTt27cP2GFs2rRJTU1NOnDggI4ePdpn3fz587VkyRJ1dXXpiSee6LMuFotpy5YtkqSdO3cO2NmsXbtWkydP1qFDh3Tw4ME+6y666CJdcsklymazA75XY4yuvfZaSeX3sP8P/qWXXqoZM2bo2LFjev75vmdyTZs2TatXr1ahUKj5Hm7dulWRSER79+5Ve3t7n3VLly7V3Llzdfr0abW1tfVZ19LSog0bNkhSzde94oorlEwmtX//fh0/frzPuoULF2rRokXq6OjQzp07+6xLJBK68sorJUlPPvnkgH8I1q1bp9bWVh08eFCHDh3qs27OnDlatmyZMpnMgJrC4bCuvrp8aZ1du3YN2NmvWrVK06dP19GjR7Vv3z5J0jPPlCdTmj59ulatWqV8Pl/ze73mmmtkjNHu3bt19uzZPuuWL1+u2bNn6+TJk9q9e3efda2trVq3bp2stTVfd/PmzYrH43r++ed18uTJPusWL16sBQsW6MyZM3r66af7rEulUrr88sslSTt27BjwD8yGDRvU0tKigwcP6vDhw33WzZ07V0uXLlVXV5d27NjRZ100GtVVV10lSXrqqacG/AO/Zs0aTZ06VUeOHNGBAwf6rJs5c6ZWrlypXC5X83tlH1Hmxz7i4MGDmjZtGvuIMewjerGPKGvEfURLS4t6enpULBYH/DxK7CN68XtE2UTdR5RKJRUKhXO/t/RiH1HG7xFljbyP6G/Xrl2yZyaf20f0/zlvdKaeZ5cYY0oaOGWt+j02qPGawcUYM0PnL6r6bWvt64cZf0zlJs1T1to1o9jOn0v6+6qHNlhrtw8y9j8kvbby5Vpr7ZPDvf7tt98+T9JBSXr1q1+t6dOnn1sXiUSUSCRUKpXO/SPQ2y2sXqb7OjG7r679haa9vV1tbW1asWKFUqkUf8Ud5XvIX2gmxj4ik8mora3t3C/q7CMa96+47CPGvo/IZrPatWuX1q9fX/Mij+wjyvg9omyi7iM6Ojq0ffv2c7+3jOQ9ZB9Rxu8R5/m5j1j0V3f2efw7b92oSy6adC7Phw8f1h133NG7ev773ve+IS8Z4Te/mh79mx0jubSxHcemR0JSb2LvtNa+fJjxXSoftfEza+2WUWznDyT9Y+XLE9bamUOMvVlSb3JuttZ+abjXr2563HLLLZozZ85ISwMmlM7OTm3btu3cXzKAICLncAE5hwvIOSa6/k2Pu951rZbPOp/ljo4OfepTn+r9suGbHvWevaWXVd+jO+wwt/HdeHnq2N7joeYNNdYYM0XnT1M5ONTYGqrHDxeE6rEzRrkdAAAAAADQjx9NDzOGmxd6T/RaaowZ6tomK6qWnxl0VG3VJ+QNd5RK9fqhptCtKZFIDD8ImKCSyaTWrl3b52JgQNCQc7iAnMMF5BxoLPWesvbNdd7eUB6UdI3KR3FslPTzQcZdV7X80Gg2YK09YIx5QdICSYuGmaL34qrlQ4OMGVQkUu+PEqifSCSiyZMn+10G4ClyDheQc7iAnAONpd5T1n6tntsbxnclvbuy/GbVaHoYY0IqzzAjSWck3TeG7fynpHepPD3tSyXdM8i411QtPzjajfS/gA0QJLlcTocOHdLcuXMVj8f9LgfwBDmHC8g5XEDOgcbi1zU9fGetfVTSA5Uv32KMqXWB0j+TtLKy/BlrbZ9L+RpjrjfG2Mrtq4Ns6tOSei8f/EljzKT+A4wxb5R0feXLO621o712yICrDANB0tPTo4MHDw646jUQJOQcLiDncAE5BxpLwzQ9jDGRYa6t4YV3qDyLS0TSXcaYdxtjNhtjXmKM+SdJH6uM2y3pE2PZgLX2BUnvrXy5RtKjxpg3G2M2VrbzOUlfrazvUPmoEAAAAAAAcIF8uxCEMSYm6fcl3STpckmTK4+fkfSYpO9I+oq11rMWqbV2uzHmNyV9Q+XTTz5cY9huSTdaawdO6Dzy7fy9MWaqpL+UdImkL9cYdlzSTdbaPWPdDgAAAAAAOM+XIz2MMRskPSvpC5J+WdIUnZ+pZUrlsX+Q1GaMWe9lLdba70u6TNKnVG5wZFS+fscvVG5SrLfW7h2H7bxb0lZJX5e0X1JO0lmVGzy3SVpurX3kQrcDAAAAAADK6n6khzHmMkk/lZTU+elo+89o0vv4Ikk/NcZssdY+5VVN1toDkm6t3EbzvP/VKKbUrTQ1PGlsMHsLgiwajeqiiy5SNBr1uxTAM+QcLiDncAE5BxpLXf+nXJkN5VuSUio3OgabvrX68SZJ3zLGrBliulfnJRIJv0sAPJNIJHTJJZf4XQbgKXIOF5BzuICcA42l3qe3vEbSCvVtaphBbtVWSvr1ehQ4URWLRb9LADxTLBaVTqfJOQKNnMMF5BwuIOdAY6l30+OmqmUj6aSkd0paJilRuS2rPHZyiOein+7ubr9LADyTyWT0i1/8QplMxu9SAM+Qc7iAnMMF5BxoLPW+EMQVKh/lYSSlJV1lrX2u35jnJH3WGPNDSdt1/tofV9SzUAAAAAAAMLHV+0iPmZV7K+kHNRoe51Smbr1T5091mTnYWAAAAAAAgP7q3fRIVi33P32lllNVy1ypEwAAAAAAjFi9mx7tlfuRnq5SPebM+JcDYKIwZsSzQwMTFjmHC8g5XEDOgcZR72t67NX501Q2GGNus9Z+sNZAY8xtkjbo/Ewve+tQ34TV3NzsdwmAZ1paWnTttdf6XQbgKXIOF5BzuICcA42l3k2P+yVdpfMXM32/MeaNkn4k6WBlzHxJvyppadU4K+l/61wrAAAAAACYwOp9esuXJPVOWN3b0Fgm6e2SPlq5vb3yWPUxYcXKczEIpsRCkKXTaT3++ONKp9N+lwJ4hpzDBeQcLiDnQGOpa9PDWvu8pC/ofEPD6nzzo/rW+3jvmM9ba/fVs9aJplQq+V0C4JlSqaSuri5yjkAj53ABOYcLyDmCZscLZ3S2O+93GWNW7yM9JOnPJf1AfY/ksP1uvYzK09b+Rd2qAwAAAAAAkqS/+M8nte4Dd+mVn39QP3v+1PBPaDB1b3pYawuSXiHpPSrPyNL/KI/e2xlJfy3ppspzAAAAAACAh6Y2xQY8Zq305ItndfPXfqFsvljjWY2r3hcylSRZa62kvzPGfEbSSyRdLmlGZfUJSY9Jus9ay4UqAAAAAACok9/ZvFCfuXdPzXVduYJ2H+usc0UXxpemR69KU+POyg0XIB6P+10C4JlEIqFLL71UiUTC71IAz5BzuICcwwXkHBPdu355uTYvmaZ7nzmmbS+0a9sLZ/qst3aQJzYoX5seGD/RaNTvEgDPRKNRzZgxY/iBwARGzuECcg4XkHMEwZaLp2nLxdMkSWve/2N1ZifuFSf8uJApPNDT0+N3CYBnenp6dPDgQXKOQCPncAE5hwvIOdBYPDnSwxjzk6ov/5+19h9qPD5a1lr70gurLLjYqSLIcrmcnn/+eU2ePFmx2MALKwFBQM7hAnIOF5BzoLF4dXrL9To/9eyOQR4fDTPG5wEAAAAAAEf5dU0PM4qxNDsAAAAAAMCo+dX0oJEBAAAAAAA85WXTY7CjOUZzlAdGKBJhIh4EVyQS0bRp08g5Ao2cwwXkHC4g50Bj8eoncXHVcscgj2McMQ84giyZTGr16tV+lwF4ipzDBeQcLiDnQGPxpOlhrT0wmsdx4Uqlkt8lAJ4plUoqFAqKRCIKhZhpG8FEzuECcg4XkHOgsfBTGBCZTMbvEgDPpNNpPfLII0qn036XAniGnMMF5BwuIOdAY2nIpocxZpIxZobfdQAAAAAAgImr7k0PY8ycqtu0futea4x5RlK7pKPGmFPGmA8ZY6L1rhMAAAAAAExsdW16GGOuknSw6nZb1bobJH1b0nKVZ3gxkqZI+itJX6pnnQAAAAAAYOKr95Ee1+p8Q0OS/qNq3XurHrdVNyPpDcaYLfUqEgAAAAAATHz1njx6fdVyWtLPpPIpL5KuULnJIfVtfvT6bUmPeF3gRNXU1OR3CYBnmpubtXXrVoXDYb9LATxDzuECcg4XkHOgsdT7SI9llXsraae1tlj5emu/cf8q6ccqNz96Gx9Xel/exGWMGX4QMEEZYxSJRMg5Ao2cwwXkHC4g50BjqXfTY7rONzH2VD1+adXyo9ba35F0o6TdlceMpMXelzdxdXd3+10C4JlMJqMnn3ySqZkRaOQcLiDncAE5BxqLH02PXh1Vy5dULT8sSdbaksqns/S2SFu8LW1iKxaLww8CJqhisaj29nZyjkAj53ABOYcLyDnQWOrd9KjeXnPVcnXTo/oIkM6qZY4PAwAAAAAAI1bvpseZyr2RdJUkGWMmS1pVNWZ31XJ1Y6S6AQIAAAAAADCkes/eslfSzMryMmPMwyo3NmJVY56oWl5QubeSDnlfHgAAAAAACIp6H+lxf+Xeqny0x5WSVlc9tsNae6pq/Bqd+pPPdAAAIABJREFUv/BpW10qnKBisdjwg4AJKh6Pa+nSpYrH436XAniGnMMF5BwuIOdAY6l30+OLkvKVZdvvXpL+sXfBGLNG0oyqdY95W9rERtMDQRaLxTR37lxyjkAj53ABOYcLyDnQWOra9LDW7pP0NkkFlY/06L1J0nettXdUDf/Nyn3v+p/UpcgJKp/PDz8ImKDy+byOHTtGzhFo5BwuIOdwATkHGku9j/SQtfbLKp/ScpukOyR9UtKN1tpf7zf0UUm39N6stdvqWugEk8vl/C4B8Ew2m1VbW5uy/z97dx4lx13fe//znX16ZrTYsrwIWbKQbXmXZXmRd+NALjiEJbkH8+QmQEwgPPfJMYEQwiWJbZJAAnGAAyELCRjiPMZ5kus4XIfEEMDYxuBNtmULIcuyhCxblrVrlp71+/xR1Z6emZ6e6Zmprpr6vV/n9OnqqV/X7zs9H5V6vlNdVSymXQqQGHKOEJBzhICcA9lS7xOZSpLc/VlJfzLFmH+rUzkAAAAAACCH6n6kBwAAAAAAQD3Q9AAAAAAAALmUyMdbzOwrZQ/vdfdvVPh6rdzdb5hdZfnV2NiYdglAYhobG9XV1UXOkWvkHCEg5wgBOQeyJalzerxbo5eiPSTpGxW+XguLn0fTYxLt7e1plwAkplAoaN26dWmXASSKnCME5BwhIOdAtqRyIlONXoYWAAAAAAAgEWmd08NrvGEK3d3daZcAJObo0aO67777dPTo0bRLARJDzhECco4QkHMgW5I80mOyozk4ygMAAAAAACQuqabHNWXLL0zydQAAAAAAgMQk0vRw9/tq+ToAAAAAAMBcS+ucHgAAAAAAAIlK6+otmGOFQiHtEoDEdHR06KKLLlJra2vapQCJIecIATlHCMg58m7Hvp60S6hJXZseZnaipN8o+9Jz7v6Pk4z9H5JWlX3py+7+UpL1zWcNDRy0g/xqaGhQe3t72mUAiSLnCAE5RwjIOfLuU9/aonfMo4jX+0iPt0q6WaOXoX17lbH7JH29bOwrkv4qscrmuWKxqAULFqRdBpCIvr4+7dixQytXruRNBHKLnCME5BwhIOfIm2M7WnS0OJR2GTNW78MD3hDfm6QX3f3uyQa6+39I2qnRS9y+YbKxkIaG5m8IgakMDQ1p79695By5Rs4RAnKOEJBz5M17LjtFZlOPy6p6H+mxJr53SQ9OY/xDklaMey4AAAAAAKiDd126UmuXL9K/b3pJ9z+7Tzte2pd2STWpd9PjBI39uMpU9sf3Fj8XAAAAAADU0XnLF+m85Yv0MUmv+9S3pIG0K5q+en+8pfxDbUumMb58TNsc1wIAAAAAAHKs3k2Pg/G9SbrGzCa9jlO87nUaPTLkUMK1zWvNzc1plwAkpqWlRStWrFBLS0vapQCJIecIATlHCMg5kC31bno8p9ETkx4n6S+qjP1sPEaKGh/PJVjXvMd1wJFnra2tWrlyJTlHrpFzhICcIwTkHMiWejc97o/vXVHz4zfN7EEze5eZXRzf3mVmD0h6f9k4SXqgzrXOK5wdGnk2NDSkAwcOkHPkGjlHCMg5QkDOgWypd9Pjaxr9uEqpoXGJpK9I+mF8+4qkDRptdpR8vU41zkvFYjHtEoDE9PX1adOmTerr60u7FCAx5BwhIOcIATkHsqWuTQ933yLpDo02NEqNj0q38ubIN9x9cz1rBQAAAAAA81u9j/SQpA9IekZjGx+VborHbI6fAwAAAAAAMG11b3q4+1FJl0m6S2OP7Cgp/9pdki539yP1rhMAAAAAAMxvTWlMGjcxfsnMLpD0y5IulnR8vHqvpB9L+md3fzSN+uajhoY0DtoB6qOhoUFtbW3kHLlGzhECco4QkHMgW1JpepS4+2OSHkuzhrwoFApplwAkpqOjQxdffHHaZQCJIucIATlHCMg5kC20HwEAAAAAQC6l3vQws7Vm9gEzu8XMbjWzt6Rd03zU09OTdglAYrq7u/XDH/5Q3d3daZcCJIacIwTkHCEg50C2pPbxFjN7p6SbJa2euMq+qei8HsfGX/svd/+NOpY377j71IOAecrdNTg4SM6Ra+QcISDnCAE5B7Kl7kd6WOTLkm6XdKoqXMHF3Uck/UDSyvj2q2a2uN61AgAAAACA+SuNj7f8kaQbFDU5vOw23j/F9y6pWdJ/q0t1AAAAAAAgF+ra9DCz1ZJ+V2MbHTbJ8IclHSx7fE2CpQEAAAAAgJyp95Ee79foeURMUrekL6tC48OjD8E9VbbunHoUOF+1t7enXQKQmEKhoLVr13JpZuQaOUcIyDlCQM6BbKl30+NaRUd4mKRBSZe7+/vjdZU+4rIjvjdJpyRe3TzW2NiYdglAYhobG7Vw4UJyjlwj5wgBOUcIyDmQLfVueqyI713Sf7r7pinGl1/naWEyJeVDf39/2iUAienv79e2bdvIOXKNnCME5BwhIOdAttS76dFZtvzCNMYfW7bMNZ+qGBwcTLsEIDEDAwPavXu3BgYG0i4FSAw5RwjIOUJAzoFsqXfTo/zEpCsmHTXqPI02Ow5WGwgAAAAAAFCu3k2PHYrOz2GSfs7MXjvZQDP7BUlnxA9d0tbEqwMAAAAAALlR76bHD+J7l9Qs6ftm9v5xY5aZ2cck3anRk55K0v31KREAAAAAAORBvZseX9Xox1Vc0jJJX4ofl44A+WVJfyyp/BqsI5Juq0+J81NTU9PUg4B5qrm5WSeddJKam5vTLgVIDDlHCMg5QkDOgWypa9PD3X8i6WsaPXqj/EiOklLzo7w58hV3316XIueptra2tEsAEtPW1qZTTz2VnCPXyDlCQM4RAnIOZEu9j/SQpP8p6cca2/iodFM85seSPljnGued4eHhtEsAEjM8PKyjR4+Sc+QaOUcIyDlCQM6BbKl708Pd+yRdLekvJQ1p9MiO8bdhSX8l6XXxc1BFXx8vEfKrt7dXjz/+uHp7e9MuBUgMOUcIyDlCQM6BbEnlRBDu3i/pt8zsTyX9oqSLJR0Xr94r6RFJ33T3XWnUBwAAAAAA5r9Uz37p7rsVHc3xV2nWAQAAAAAA8qeuTQ8zKz8Zab+kC9yd474AAAAAAMCcq/eRHssVnUfEJP0HDY+5Yzb+IjhAfpiZGhsbyTlyjZwjBOQcISDnQLbUu+nxsqQTFV2dZUed5861jo6OtEsAEtPZ2anLL7887TKARJFzhICcIwTkHMiWel+95WGNXqr22DrPDQAAAAAAAlLvpsdfx/cm6Q1mdkyd56/IzFaY2a1mtsXMeszsgJk9YmYfMbNCQnMWzGy7mXl82zGb7XFJLORZT0+PHnnkEfX09KRdCpAYco4QkHOEgJwD2VLXpoe73yvp8/HDBZL+j5mtqGcN45nZmyU9JelDkk6XVJC0WNJ6SZ+WtNHMVicw9ScknTJXGxsZGZmrTQGZMzIyot7eXnKOXCPnCAE5RwjIOZAt9b56yx9KOijpBUmvkXSxpGfN7H5FjYdDis73UZG7f2KO6zlf0p2S2iV1S/qUpO/Fj6+X9BuSTpN0j5mtd/ejczjvByUVJQ1K6pqL7QIAAAAAgFH1PpHpzRptariij7k0Sbo6vk1lTpseio46aZc0JOkN7v5Q2brvmtmzio72OE3ShxXVPytm1ijpy5IaJd0i6QbR9AAAAAAAYM7V+5weJRbfXKPNj6luc1uA2UWSrogf/v24hkfJrZJ+Ei/faGbNczD1jZIukPRTSX82B9sDAAAAAAAVpNX0KDU7xj+e7JaEt5Ytf7XSAHcfkfT1+OEiSdfMZsL4/CWlo1V+090HZrO9cm1tbXO1KSBz2tvbddZZZ6m9vT3tUoDEkHOEgJwjBOQcyJY0mh7TOaoj0aM8YqWLZ/dIeqzKuPvKli+b5ZxfktQh6R/c/fuz3NYYTU31/qQSUD9NTU1asmQJOUeukXOEgJwjBOQcyJZ6/0t8T53nq+aM+H6buw9VGbelwnNqZmbXS3qTohO5fnim25nMwMCcHTQCZM7AwID27NmjE044QS0tLWmXAySCnCME5BwhIOdAttS16eHuX6vnfJMxszZJS+KHL1Qb6+4HzaxH0REay2c432JJn4sf/p67vzKT7VRz4MCBKXeqCxYsmOtpgbro7+/X888/r8WLF/PmAblFzhECco4QkHMgW+p9ydpGScdKKrr7kXrOPU751VK6pzG+1PTonOF8n5F0vKSHFF25Zc7dcccdU4750Ic+9OpyV1f0EvT29mp4eHjMuLa2NjU3N2tgYED9/f1j1jU2NqpQKMjd1d098aXr6OhQQ0OD+vr6NDQ09gCa1tZWtbS0aHBwUMViccy6hoYGdXR0SJKOHp14ZeBCoaDGxkYVi0UNDg6OWdfS0qLW1lYNDQ2pr69vzDozU2dn9GPr7u6W+9hTxLS3t6upqUn9/f0TjpZpbm5WW1ubhoeH1dvbO6Gm0mvY09Mz4Trs1V7DpqYmtbe3a2RkRD09PRO229nZKTOr+LOp9hqWfjZS5dew2s+m2mtY/rOp9BqWfja1voblP5tKr2HpZzMwMPDqc0v3s3kNSz+baq/hbPI9m9ewWr5n8xpW+tlM9Rqyj4jUcx9R2kZ/f7+6urrYR9Swj5jL/Sz7iEhS+4jSa+ruNecw9H1ECe8jIlnfR0iaUDP7iAjvIyLzeR8Rnfpy/ki86WFmJunXJb1X0nrF5xExswOS/l3Sp9x9y+RbSET5WT+n87mQUpJqPhuRmV2p6PsfUnTy0qROzDqlxx9//NXlq666SpK0ZcuWCf/w16xZo+OPP16vvPKKtm3bNmbd4sWLde6552p4eHjM9ko2bNiglpYWPffcc9q/f/+YdatWrdLy5ct16NAhbd68ecy6zs5OXXDBBZKkjRs3TthhrF+/Xh0dHdq5c6f27NkzZt3y5cu1atUqdXd368knnxyzrqWlRRs2bJAkbdq0acLO5rzzztOiRYu0e/du7dq1a8y6E044QaeffrqKxeKE79XMdOWVV0qKXsPxO+UzzzxTxx13nF5++WVt3759zLpjjz1WZ599toaGhiq+hpdddpmampq0bds2HTx4cMy61atXa9myZTpw4IC2bBn7z6arq0vr1q2TpIrbveiii9Te3q4dO3Zo7969Y9atWLFCK1eu1JEjR7Rp06Yx69ra2nTxxRdLkp566qkJ/xGsXbtWCxcu1K5du7R79+4x60466SSdeuqp6u3tnVBTY2OjLr88OrXO5s2bJ+zszzrrLC1ZskR79uzR888/L0mvfs9LlizRWWedpcHBwYrf6xVXXCEz09atW3X48OEx60477TSdeOKJ2rdvn7Zu3Tpm3cKFC7V27Vq5e8XtXnLJJWptbdX27du1b9++MetOOeUUnXzyyTp06JCeeeaZMesKhYIuvPBCSdITTzwx4T+YdevWqaurS7t27dKLL744Zt2yZcu0evVqdXd364knnhizrrm5WZdeeqkk6emnn57wn9M555yjY445Ri+99JJ27tw5Zt3SpUt1xhlnqL+/v+L3yj4iksY+4oUXXtCSJUvYR8xgH1HCPiKSxX1E6U38yMjIhH+PEvuIEt5HRObzPkLShNeYfUSE9xGR+byPGP/vOOssyd/Bzawg6S5JP1f60rghrqgZ8C53/0ZihUys6zhJpb31ne5+/RTjX5a0VNLT7n5ODfO0SnpS0umSbnX336kwZoekFZJ2uvvK6W5bkm655ZbXSNolSW9729u0ZMmSV9c1NTWpra1NIyMjr/4nUHqjUb5M9zWf3de8/YXm4MGD2rJli9asWaNCocBfcWt8DfkLzfzYR/T29mrLli2vvlFnH5Htv+Kyj5j5kR6bN2/W+eefr+jvYmOxj4jwPiIyX/cRR44c0caNG1993zKd15B9RIT3EaOyvI+45pP36OrBR0urlt90001VTxmRtqSbHl+R9O6yL42frPS/3aCkDe4+sRWVTF1tkkqJvcfdf2GK8d2KPt7yI3ffUMM8n5D0B4oaE2e4+4TUzVXT4wMf+ICWLl1ay9OBeaOvr0/bt2/XqlWruPwbcoucIwTkHCEg58i7133qW7pq4OHSw8w3PRL7eIuZnaOo4VGtq1Ja1yzp0xo9IiRR7l40s/2Kzi/ymmpj45OQdsQPd1UbW8FH4/vvSHpzpb9olG27I77CiyTtdffv1jJRW1vb1IOAeap0vXsgz8g5QkDOEQJyDmRLkuf0eFeFr1X6eEvJNWa23N1rbSzM1GZJV0habWZNVS5bu6Zs+Sc1zlE6XfN7NPXlepdIKp2N9D5JNTU9xh/yBOTJyMiIBgcH1dzcrIaGhrTLARJBzhECco4QkHMgW5L8V3hp2bJJOijp45LeLOnXJN2tiU2QaX90ZA48EN93SLqgyrirypYfTK6c2an0OTAgL3p6evSjH/2o4ucSgbwg5wgBOUcIyDmQLUk2PV6r6EgOk1SUdKm7f8rd73H32939bZL+UmMbH69NsJ7x/rVsueJRGGbWoKhBI0mHJH2vlgnc3aa6SSqdCnln2devrvF7AQAAAAAA4yTZ9FgY37uk77j71gpjPlc2RpIWJVjPGO7+sKT744c3mFmlo0w+LOmMePnz7j7mVL5mdrWZeXy7LblqAQAAAABArZI8p0eLRpsZz08yZvu4x83JlVPRjYo+stIu6V4z+6SioznaJV0v6X3xuK2Sbq1zbQAAAAAAYBaSbHqUG670RXf3Sa5oUhfuvtHM3iHpdkkLJH2ywrCtkq5z94kXdAYAAAAAAJlVr6ZHZrn7N83sXEVHfVyn6BK2A5K2Sfr/JH3R3TN/ltCOjo6pBwHzVGdnp6644gql2SQFkkbOEQJyjhCQcyBb6tX0+GUzWzvLce7u185lUWUb3inpQ/Gtlud9XxOvQFPr3Ctn8/wSdqrIMzMj48g9co4QkHOEgJwD2VKPpodJWhbfqo1RlXGm0fODoIK+vj4tWLAg7TKARPT29mrr1q067bTTVCgU0i4HSAQ5RwjIOUJAzoFsqdeRHtNtdVYaR7NjGoaHK542BciF4eFhHT58mJwj18g5QkDOEQJyDmRLPZoeNC0AAAAAAEDdJd304MNsAAAAAAAgFUk2PW5JcNsAAAAAAABVJdb0cHeaHnXU2tqadglAYtra2nTaaaepra0t7VKAxJBzhICcIwTkHMiWep3IFAlrbm5OuwQgMc3NzTrxxBPTLgNIFDlHCMg5QkDOgWxpSLsAzI3BwcG0SwASMzg4qJdeeomcI9fIOUJAzhECcg5kC02PnOjv70+7BCAxxWJRW7duVbFYTLsUIDHkHCEg5wgBOQeyhaYHAAAAAADIJZoeAAAAAAAgl2h6AAAAAACAXKLpkRONjY1plwAkprGxUQsXLiTnyDVyjhCQc4SAnAPZwiVrc6K9vT3tEoDEFAoFrV27Nu0ygESRc4SAnCME5BzIFo70yAl3T7sEIDHurpGREXKOXCPnCAE5RwjIOZAtND1yoqenJ+0SgMR0d3fr/vvvV3d3d9qlAIkh5wgBOUcIyDmQLTQ9AAAAAABALtH0AAAAAAAAuUTTAwAAAAAA5BJNDwAAAAAAkEtcsjYnCoVC2iUAieno6NAll1yi5ubmtEsBEkPOEQJyjhCQcyBbaHrkREMDB+0gvxoaGtTa2pp2GUCiyDlCQM4RAnIOZAu/KedEsVhMuwQgMX19fXrmmWfU19eXdilAYsg5QkDOEQJyDmQLTY+cGBoaSrsEIDFDQ0Pat28fOUeukXOEgJwjBOQcyBaaHgAAAAAAIJdoegAAAAAAgFyi6QEAAAAAAHKJpkdOtLS0pF0CkJjW1ladcsopnAkduUbOEQJyjhCQcyBbuGRtTtD0QJ61tLTo5JNPTrsMIFHkHCEg5wgBOQeyhSM9coKzQyPPOAs6QkDOEQJyjhCQcyBbaHrkRLFYTLsEIDFc7x4hIOcIATlHCMg5kC00PQAAAAAAQC7R9AAAAAAAALlE0wMAAAAAAOQSTY+caGjgR4n8amhoUKFQIOfINXKOEJBzhICcA9nCJWtzolAopF0CkJiOjg5deOGFaZcBJIqcIwTkHCEg50C20H4EAAAAAAC5RNMjJ3p6etIuAUhMd3e3HnjgAXV3d6ddCpAYco4QkHOEgJwD2ULTIyfcPe0SgMS4u4aHh8k5co2cIwTkHCEg50C20PQAAAAAAAC5RNMDAAAAAADkEk0PAAAAAACQSzQ9cqK9vT3tEoDEFAoFrVu3jkszI9fIOUJAzhECcg5kS1PaBWBuNDY2pl0CkJjGxkZ1dXWlXQaQKHKOEJBzhICcA9nCkR45USwW0y4BSEyxWNSzzz5LzpFr5BwhIOcIATkHsoWmR04MDQ2lXQKQmMHBQb344osaHBxMuxQgMeQcISDnCAE5B7KFpgcAAAAAAMglmh4AAAAAACCXaHoAAAAAAIBcoumRE83NzWmXACSmpaVFy5YtU0tLS9qlAIkh5wgBOUcIyDmQLVyyNidaW1vTLgFITGtrq1avXp12GUCiyDlCQM4RAnIOZAtHeuTE8PBw2iUAiRkeHtbhw4fJOXKNnCME5BwhIOdAttD0yIm+vr60SwAS09vbqyeeeEK9vb1plwIkhpwjBOQcISDnQLbQ9AAAAAAAALlE0wMAAAAAAOQSTQ8AAAAAAJBLND1ywszSLgFIjJmpubmZnCPXyDlCQM4RAnIOZAuXrM2Jjo6OtEsAEtPZ2alLL7007TKARJFzhICcIwTkHMgWjvQAAAAAAAC5RNMjJ7gkFvKsp6dHP/7xj9XT05N2KUBiyDlCQM4RAnIOZAtNj5wYGRlJuwQgMSMjIyoWi+QcuUbOEQJyjhCQcyBbaHoAAAAAAIBcoukBAAAAAAByiaYHAAAAAADIJZoeOdHW1pZ2CUBi2tvbdc4556i9vT3tUoDEkHOEgJwjBOQcyJamtAvA3Ghq4keJ/GpqatIxxxyTdhlAosg5QkDOEQJyDmQLR3rkRH9/f9olAInp7+/Xjh07yDlyjZwjBOQcISDnQLbQ9MiJwcHBtEsAEjMwMKCdO3dqYGAg7VKAxJBzhICcIwTkHMgWmh4AAAAAACCXaHoAAAAAAIBcoukBAAAAAAByiaZHTnD1FuRZU1OTli5dSs6Ra+QcISDnCAE5B7KFf4k50dbWlnYJQGLa29t1xhlnpF0GkChyjhCQc4SAnAPZwpEeOTEyMpJ2CUBiRkZG1NfXR86Ra+QcISDnCAE5B7KFpkdO9Pb2pl0CkJienh49/PDD6unpSbsUIDHkHCEg5wgBOQeyhaYHAAAAAADIJZoeAAAAAAAgl2h6AAAAAACAXKLpAQAAAAAAcolL1uZEZ2dn2iUAienq6tJVV12VdhlAosg5QkDOEQJyDmQLR3oAAAAAAIBcoumRE319fWmXACSmt7dXjz/+OJdmRq6Rc4SAnCME5BzIFpoeOTE8PJx2CUBihoeHdfToUXKOXCPnCAE5RwjIOZAtND0AAAAAAEAu0fQAAAAAAAC5RNMDAAAAAADkEk2PnGhtbU27BCAxbW1tWrNmjdra2tIuBUgMOUcIyDlCQM6BbGlKuwDMjebm5rRLABLT3Nys448/Pu0ygESRc4SAnCME5BzIFo70yImBgYG0SwASMzAwoN27d5Nz5Bo5RwjIOUJAzoFsoemRE+xUkWf9/f3atm2b+vv70y4FSAw5RwjIOUJAzoFsoekhycxWmNmtZrbFzHrM7ICZPWJmHzGzwiy3XTCzt5vZX8XbPGhmg2a238weMrObzeyEufpeAAAAAABAJPhzepjZmyXdLmlB2ZcLktbHt/ea2XXuvm0G2z5X0oOSOiusPkbSJfHtt83sfe5+Z61zAAAAAACAyoI+0sPMzpd0p6KGR7ekj0u6VNK1kr4cDztN0j1m1jWDKRZotOHxoKSPSXq9pHWSfl7S30gaicf9o5m9cWbfCQAAAAAAGC/0Iz0+L6ld0pCkN7j7Q2Xrvmtmz0r6tKLGx4cl3Vzj9kck/ZOkW9x9c4X195rZtyTdJalR0hfM7FR39xrnUWNjY61PAeaNxsZGLV68mJwj18g5QkDOEQJyDmRLsEd6mNlFkq6IH/79uIZHya2SfhIv32hmNV0X1t1/6O7vmKThURpzt6T/HT98raTza5mjpL29fSZPA+aFQqGgc889V4XCrE6xA2QaOUcIyDlCQM6BbAm26SHprWXLX600wN1HJH09frhI0jUJ1fK9suXXzmQDMzg4BJg33F1DQ0PkHLlGzhECco4QkHMgW0Juelwe3/dIeqzKuPvKli9LqJbWsuXhmWygp6dnjkoBsqe7u1sPPviguru70y4FSAw5RwjIOUJAzoFsCfmcHmfE99vcfajKuC0VnjPXripb/smko6ro7u7WkSNHqo5ZsGBB1fUAAAAAAORJkE0PM2uTtCR++EK1se5+0Mx6JHVIWp5ALedJui5+uMndZ9T0uOOOO6Yc86EPfejV5a6u6GI0vb29Gh4ee3BJW1ubmpubNTAwoP7+/jHrGhsbVSgU5O4Vu9cdHR1qaGhQX1+fhobG9pJaW1vV0tKiwcFBFYvFMesaGhrU0dEhSTp69OiE7RYKBTU2NqpYLGpwcHDMupaWFrW2tmpoaEh9fX1j1pmZOjujC+h0d3dPOMywvb1dTU1N6u/v18DAwJh1zc3Namtr0/DwsHp7eyfUVHoNe3p6NDIyMmZdtdewqalJ7e3tGhkZqXiETmdnp8ys4s+m2mtY+tlIlV/Daj+baq9h+c+m0mtY+tnU+hqW/2wqvYaln83AwMCrzy3dz+Y1LP1sqr2Gs8n3bF7DavmezWtY6Wcz1WvIPiJSz31EaRv9/f3q6upiH1HDPmIu97PsIyJJ7SNKr6m715zD0PcRJbyPiGR9HyFpQs3sIyK8j4jM531EdBaI+SPIpoek8svPTue4s1LTo3OqgbUws1ZJf6foyi1SdMncxDz++OOvLl91VXRwyZYtWyb8w1+zZo2OP/54vfLKK9q2bduYdYsXL9YboWDgAAAgAElEQVS5556r4eHhMdsr2bBhg1paWvTcc89p//79Y9atWrVKy5cv16FDh7R589hzu3Z2duqCCy6QJG3cuHHCDmP9+vXq6OjQzp07tWfPnjHrli9frlWrVqm7u1tPPvnkmHUtLS3asGGDJGnTpk0TdjbnnXeeFi1apN27d2vXrl1j1p1wwgk6/fTTVSwWJ3yvZqYrr7xSUvQajt8pn3nmmTruuOP08ssva/v27WPWHXvssTr77LM1NDRU8TW87LLL1NTUpG3btungwYNj1q1evVrLli3TgQMHtGXLljHrurq6tG7dOkmquN2LLrpI7e3t2rFjh/bu3Ttm3YoVK7Ry5UodOXJEmzZtGrOura1NF198sSTpqaeemvAfwdq1a7Vw4ULt2rVLu3fvHrPupJNO0qmnnqre3t4JNTU2Nuryy6NPmW3evHnCzv6ss87SkiVLtGfPHj3//POS9Or3vGTJEp111lkaHBys+L1eccUVMjNt3bpVhw8fHrPutNNO04knnqh9+/Zp69atY9YtXLhQa9eulbtX3O4ll1yi1tZWbd++Xfv27Ruz7pRTTtHJJ5+sQ4cO6ZlnnhmzrlAo6MILL5QkPfHEExP+g1m3bp26urq0a9cuvfjii2PWLVu2TKtXr1Z3d7eeeOKJMeuam5t16aWXSpKefvrpCf85nXPOOTrmmGP00ksvaefOnWPWLV26VGeccYb6+/srfq/sIyJp7CNeeOEFLVmyhH3EDPYRJewjIlncR5TexI+MjEz49yixjyjhfURkPu8jJE14jdlHRHgfEZnP+4jx/46zzkI8wY6ZLZf0s/jhP7j7r00x/meKjvJ4zt1Xz2EdX5b03vjh19z93bU8/5ZbbnmNpF2S9La3vU1Llix5dV1TU5Pa2to0MjLy6n8CpTca5ct0X/PZfc3bX2gOHjyoLVu2aM2aNSoUCvwVt8bXkL/QzI99RG9vr7Zs2fLqG3X2Edn+Ky77iJkf6bF582adf/75MrMJ22UfEeF9RGS+7iOOHDmijRs3vvq+ZTqvIfuICO8jRmV5H3HNJ+/R1YOPllYtv+mmm6p+eiJtoTY9jpNUalHf6e7XTzH+ZUlLJT3t7ufMUQ0fk/TJ+OEjkq5x95rORlre9Ljxxhu1aNGiuSgNyJyRkRENDQ2pqalJDQ0hn38ZeUbOEQJyjhCQc+Td6z71LV018HDpYeabHqF+vKW8vTedj6x0xPdzcgpmM3u/RhseWyS9qdaGx3jsUJFnDQ0NamlpSbsMIFHkHCEg5wgBOQeyJcjflN29KKn0IbDXVBtrZos12vTYVW3sdJjZOyV9KX64U9Lr3X1fladMy/jDj4A86evr09NPPz3hkEIgT8g5QkDOEQJyDmRLkE2PWOnsNqvNrNoRL2vKlmd0ZZUSM/tFSV9X9Lq/JOlad5+TQ4HGf6YNyJOhoSHt37+fnCPXyDlCQM4RAnIOZEvITY8H4vsOSRdUGXdV2fKDM53MzK6V9E+KPlK0X9ERHs/NdHsAAAAAAKC6kJse/1q2/J5KA8ysQVLpyi6HJH1vJhOZ2aWS7pbUKumwpJ9392eqPwsAAAAAAMxGsE0Pd39Y0v3xwxvMbEOFYR+WdEa8/Hl3H3P9IjO72sw8vt1WaR4zWyvpHkVHlPRIus7dH5uL7wEAAAAAAEwu1Ku3lNyo6CMr7ZLuNbNPKjqao13S9ZLeF4/bKunWWjduZq+V9J+SSteS/X1Jh83s7CpP2+vue6usr4gzRCPPWltbtWrVKrW2tqZdCpAYco4QkHOEgJwD2RJ008PdN5rZOyTdLmmBRi8jW26roqMzjlZYN5UrJC0te/zZaTznFkk31zoRTQ/kWUtLi5YvX552GUCiyDlCQM4RAnIOZEuwH28pcfdvSjpXUUNiq6ReRefveFTSRyWd7+7b0qtwegYHB6ceBMxTg4ODeuWVV8g5co2cIwTkHCEg50C2BN/0kCR33+nuH3L30929w90Xu/uF7v5pd++t8rzvu7vFt3dXWH9b2frp3m6eyffQ398/k6cB80KxWNTmzZtVLBbTLgVIDDlHCMg5QkDOgWyh6QEAAAAAAHKJpgcAAAAAAMglmh4AAAAAACCXaHrkREMDP0rkV0NDgzo7O8k5co2cIwTkHCEg50C2BH3J2jwpFApplwAkpqOjQxdccEHaZQCJIucIATlHCMg5kC20HwEAAAAAQC7R9MiJ7u7utEsAEnP06FH94Ac/0NGjR9MuBUgMOUcIyDlCQM6BbKHpAWBecPe0SwASR84RAnKOEJBzIDtoegAAAAAAgFyi6QEAAAAAAHKJpgcAAAAAAMglLlmbE+3t7WmXACSmUCho/fr1amtrS7sUIDHkHCEg5wgBOQeyhSM9cqKxsTHtEoDENDY2qqOjg5wj18g5QkDOEQJyjrz74v91ftol1ISmR04Ui8W0SwASUywW9dOf/pScI9fIOUJAzhECco68e83iQtol1ISmR04MDQ2lXQKQmMHBQe3Zs0eDg4NplwIkhpwjBOQcISDnQLbQ9AAAAAAAALlE0wMAAAAAAOQSTQ8AAAAAAJBLND1yorm5Oe0SgMS0tLRo+fLlamlpSbsUIDHkHCEg5wgBOQeypSntAjA3Wltb0y4BSExra6tWrVqVdhlAosg5QkDOEQJyDmQLR3rkBFdvQZ4NDQ3p0KFD5By5Rs4RAnKOEJBzIFtoeuQE1wFHnvX19enJJ59UX19f2qUAiSHnCAE5RwjIOZAtND0AAAAAAEAu0fQAAAAAAAC5RNMDAAAAAADkEk2PnDCztEsAEmNmamlpIefINXKOEJBzhICcA9nCJWtzoqOjI+0SgMR0dnZqw4YNaZcBJIqcIwTkHCEg50C2cKQHAAAAAADIJZoeOdHT05N2CUBiuru79dBDD6m7uzvtUoDEkHOEgJwjBOQcyBaaHjnh7mmXACTG3TUwMEDOkWvkHCEg5wgBOQeyhaYHAAAAAADIJZoeAAAAAAAgl2h6AAAAAACAXKLpkRNtbW1plwAkpr29Xeedd57a29vTLgVIDDlHCMg5QkDOgWxpSrsAzI2mJn6UyK+mpiYtWrQo7TKARJFzhICcIwTkHMgWjvTIif7+/rRLABLT39+v7du3k3PkGjlHCMg5QkDOgWyh6ZETg4ODaZcAJGZgYEC7du3SwMBA2qUAiSHnCAE5RwjIOZAtND0AAAAAAEAu0fQAAAAAAAC5RNMDAAAAAADkEk2PnODqLciz5uZmnXDCCWpubk67FCAx5BwhIOcIATkHsoXflHOira0t7RKAxLS1ten0009PuwwgUeQcISDnCAE5B7KFIz1yYnh4OO0SgMQMDw+rp6eHnCPXyDlCQM4RAnIOZAtNj5zo6+tLuwQgMb29vXr00UfV29ubdilAYsg5QkDOEQJyDmQLTQ8AAAAAAJBLND0AAAAAAEAu0fQAAAAAAAC5RNMDwLxgZmmXACSOnCME5BwhIOdAdnDJ2pzo7OxMuwQgMV1dXbryyivTLgNIFDlHCMg5QkDOgWzhSA8AAAAAAJBLND1ygktiIc96enr02GOPqaenJ+1SgMSQc4SAnCME5BzIFpoeOTEyMpJ2CUBiRkZG1N3dTc6Ra+QcISDnCAE5B7KFpgcAAAAAAMglmh4AAAAAACCXaHoAAAAAAIBcoumRE62trWmXACSmra1NZ555ptra2tIuBUgMOUcIyDlCQM6BbGlKuwDMjebm5rRLABLT3Nys4447Lu0ygESRc4SAnCME5BzIFo70yImBgYG0SwASMzAwoF27dpFz5Bo5RwjIOUJAzoFsoemRE+xUkWf9/f3avn27+vv70y4FSAw5RwjIOUJAzoFsoekBAAAAAAByiaYHAAAAAADIJZoeAAAAAAAgl2h65ERTExfiQX41NTXp2GOPJefINXKOEJBzhICcA9nCv8Sc4DrgyLP29nadffbZaZcBJIqcIwTkHCEg50C2cKRHToyMjKRdApCYkZERDQwMkHPkGjlHCMg5QkDOgWyh6ZETvb29aZcAJKanp0cPPfSQenp60i4FSAw5RwjIOUJAzoFsoekBAAAAAAByiaYHAAAAAADIJZoeAAAAAAAgl2h6AAAAAACAXOKStTnR0dGRdglAYjo7O3XZZZepsbEx7VKAxJBzhICcIwTkHMgWmh45YWZplwAkxszU1MTuCvlGzhECco4QkHMgW/h4S0709fWlXQKQmN7eXj311FNcmhm5Rs4RAnKOEJBzIFtoeuTE8PBw2iUAiRkeHtbBgwfJOXKNnCME5BwhIOdAttD0AAAAAAAAuUTTAwAAAAAA5BJNDwAAAAAAkEs0PXKipaUl7RKAxLS2tmr16tVqbW1NuxQgMeQcISDnCAE5B7KFaynlBE0P5FlLS4uWLVuWdhlAosg5QkDOEQJyDmQLR3rkxODgYNolAIkZHBzUyy+/TM6Ra+QcISDnCAE5B7KFpkdO9Pf3p10CkJhisagtW7aoWCymXQqQGHKOEJBzhICcA9lC0wMAAAAAAOQSTQ8AAAAAAJBLND0AAAAAAEAu0fTIicbGxrRLABLT2Niorq4uco5cI+cIATlHCMg5kC1csjYn2tvb0y4BSEyhUNC6devSLgNIFDlHCMg5QkDOgWzhSA8AAAAAAJBLND1yoru7O+0SgMQcPXpU9913n44ePZp2KUBiyDlCQM4RAnIOZAtNDwAAAAAAkEuc02N+O6G0wJEeyKsjR47os5/9rCTp1FNPVVdXV8oVAXOPnCME5BwhIOcIwbijmE6Q9EJKpUwLR3pIMrMVZnarmW0xsx4zO2Bmj5jZR8ysMIfzvNHM7jKzF8ysP76/y8zeOFdzAAAAAACASPBHepjZmyXdLmlB2ZcLktbHt/ea2XXuvm0WczRI+ltJN4xbtSy+vdXM/k7S+919ZKbzAAAAAACAUUEf6WFm50u6U1HDo1vSxyVdKulaSV+Oh50m6R4zm82xaX+i0YbHRknvlHRRfL8x/vp7Jf3xTCfgkrUIQaEwZwdeAZlFzhECco4QkHMgG0I/0uPzktolDUl6g7s/VLbuu2b2rKRPK2p8fFjSzbVOYGanSfqd+OGjkq5097748SNm9m+S7lN0VMlHzOwrMzmqpKEh6P4VAkHOEQJyjhCQc4SAnAPZEOy/RDO7SNIV8cO/H9fwKLlV0k/i5RvNrHkGU31Qo82l3ypreEiS3L1X0m/FD5sk/fYM5lB/f/9MngbMK8ViMe0SgMSRc4SAnCME5BzIhmCbHpLeWrb81UoD4vNrfD1+uEjSNbVMYGYm6S3xwy3u/qNJ5vmRpJ/GD98SP68mQ0NDtT4FmHfIOUJAzhECco4QkHMgG0Juelwe3/dIeqzKuPvKli+rcY5TJJ1UYTvV5lkmaWWN8wAAAAAAgHFCPqfHGfH9Nnev1obdUuE503XmJNuZzjzPT2P7jaWF/fv3a/fu3VUHc51wzEfl1wHv7u7WkSNHUqwGSAY5RwjIOUJAzhGCnp6e8oeNk43LiiCbHmbWJmlJ/PCFamPd/aCZ9UjqkLS8xqleU7ZcdR5Ju8qWpzvPsaWFe++9d7o1AfPWHXfckXYJQOLIOUJAzhECco5AHDv1kHSF+vGW8kMeuqcxvtTK6kxwnvJ22XTn2VtbOQAAAAAAzJnM/04a5JEektrKlgemMb50aZT2BOcpv/zKdOfZJOlCSUsl7Zc0PMX4PdPcLgAAAAAAlTRKOi5e3pRmIdMRatOj/PpRLdMY3xrf91UdNbt5WsuWpzXPTTfd1C/p0RprAgAAAABgNnamXcB0hfrxlqNly9P5KElHfD+dj8LMdJ6OsuVa5wEAAAAAAOME2fRw96Kij4NIY082OoGZLdZoQ2JXtbEVlJ+8tOo8Gnvy0lrnAQAAAAAA4wTZ9Ihtju9Xm1m1j/msKVv+yQznGL+duZ4HAAAAAACME3LT44H4vkPSBVXGXVW2/GCNczwv6cUK26nkyvh+t6QdNc4DAAAAAADGCbnp8a9ly++pNMDMGiT9WvzwkKTv1TKBu7uku+OHa8zskknmuUSjR3rcHT8PAAAAAADMQrBND3d/WNL98cMbzGxDhWEflnRGvPx5dx8sX2lmV5uZx7fbJpnqcxq9lOwXzGzM5Wjjx1+IHw7F4wEAAAAAwCwF2/SI3ajo8rBNku41s4+Z2SVmdo2Z/Y2kT8fjtkq6dSYTuPtWSZ+JH66X9KCZvcPM1pvZOxR9ZGZ9vP4z7v7sTL8ZAAAAAAAwykL/JIWZvVnS7ZIWTDJkq6Tr3H1bhederdGPvHzN3d89yRwNkr4s6derlPL3kt7n7iPTqxwAAAAAAFQT+pEecvdvSjpX0mcVNTh6FZ2/41FJH5V0fqWGR41zjLj7DZKuU3SOjxclDcT3d0t6t6TDkjabWY+ZHTCzR8zsI2ZWmM3c5czsjWZ2l5m9YGb98f1dZvbGuZoDmIyZrTCzW81sy1zn3MwKZvZ2M/ureJsHzWzQzPab2UNmdrOZnTBX3wswmSRzXmXOgpltL/u45Y4k5gFK6plzM/s5M7vNzLbFcx02s61m9s9m9gEz65zL+YCSeuTczFaa2Z+Z2WNmdih+73LAzH5oZn9oZkvnYh6gnJktNbNfMLNPmNm3zGzfNE7ZMNs532lm95rZHjMrmtlOM7t9klNMzP38oR/pkbbZHGlSwxwNkv5W0g1Vhv2dpPdzpAmSkGTOzexcRR8Tm+qN7xFFR1PdWescwHTUY38+ybx/rugcVCU73X3lXM4BlNQr52a2WNJXJb1liqHnu/sTs5kLGK9O789/VdLfSGqvMuyApOvd/dsznQcYz8yqNQAm/fTCDOdql/TPkt40yZARSZ9w91vmas5Kgj/SI01mdr6kOxXtULslfVzSpZKuVfRxGEk6TdI9ZtY1i6n+RKMNj42S3inpovh+Y/z190r641nMAVRUh5wv0GjD40FJH5P0eknrJP28ojcUI/G4f+TIJiShjvvzSvN+UFJR0tG52i5QSb1ybmYLJX1bow2PuyT9iqRLJF0o6e2SPi/phZnOAUymHjk3s8sk3aao4TGiqMH3VkXvz39Z0jfjocdIutvMVs1kHmAafibp3gS3/xWNNjy+p9Gc3yDpOUX9iJvN7H0J1iC5O7eUbpJ+IMklDUraUGH9R+L1LunmGc5xWrx9l/SIpPZx6wvx10t1rE77deGWr1vSOVf0RuROSWdWGfMWRW8qXNI2xUe5ceM2V7d67M8rbLNR0UcxXdIfSNoRL+9I+/Xgls9bvXIu6evxNoqSfrHKOJPUlPbrwi1ftzq9P/8/Zdv4vycZc2vZmC+m/bpwy89N0i2SfkHS8fHjlWVZu20O53ld2Xb/TVLjuPVLJO2M1x+UtDip75mPt6TEzC6S9OP44d+4+29WGNMg6WlFl809JGmpj7ts7jTm+ZKkD8QPN7j7jyqMuUTSQ/HDL7n7/6xlDmAy9cr5NGv5Z0m/FD+8wN0fn+s5EKa0cm5mH1L0pvinis5NtVXSCvHxFiSgju9bLpd0f/zwI+7+5zOvGqhNHXN+QNJiSfvdfckkYxbG25ekx939glrmAKbLzFZKej5+OGcfbzGzf5f0RklDkk5x9wlH55nZ9ZLuiB/+rrt/ZvyYucDHW9Lz1rLlr1Ya4NH5Nb4eP1wk6ZpaJjAz0+ihoVsqNTzieX6k6E2zJL0lfh4wFxLPeQ2+V7b82oTmQJjqnnMzWyHpE/HD33T3gdlsD5iGeuX8/4nvD0v64gyeD8xGvXLeEt8/P9kAdz8sad+48cC8EH/069r44XcqNTxi/1vRefck6W1J1UPTIz2Xx/c9kh6rMu6+suXLapzjFEknVdhOtXmWKTrECZgL9cj5dLWWLQ8nNAfClEbOvySpQ9I/uPv3Z7ktYDoSz7mZtWj0jzXfdvdi/PVGM1seX+mirZZtAjWq1/689MfGUyYbYGYLFB3+Xz4emC8u1GizbtLfQ+M/2pT+MH+hmTUnUQxNj/ScEd9vc/ehKuO2VHjOdJ05yXbmeh5gMvXI+XRdVbb8k4TmQJjqmvP4UNA3Kfr864enGA7MlXrk/DxJpabGJjNbYGafU/TX7p8p+qv4YTP7tpldXeO2gemo1/78r+P7Y81swkdoYn9QYTwwX8zk99AmSacmUQxNjxTEf6UodW6rnnnc3Q8q6jZL0vIap3pN2fJUZzjfVbZc6zzABHXM+XRqOU/SdfHDTe5O0wNzot45jy/j+bn44e+5+ysz2Q5QizrmvPxNcoOiE/XeqOgjBCUtkn5O0nfN7KM1bh+YVJ3351/R6Edk/tLMvmxmbzaz9Wb2djO7S9LvxOv/xN2/M4M5gDRl6vdQmh7pKL+8Vfc0xpd2qp1VR81unp6y5VrnASqpV86rMrNWSX+n6EoXUnTpOWCu1Dvnn5F0vKKTT395irHAXKlXzo8pW/6oor/4/Yeiyxu2SVqq6OTshxVdueVPzewt4zcCzFDd9ufuPuzu75L03yU9Kem9iq5u8Yikf1F0bpHvSXq9u/9+rdsHMiBTv4fS9EhH+edRp3Pyuf74vj3BefrLlmudB6ikXjmfyhclrY+Xv+bu35zj7SNsdcu5mV0p6dcVnQX9N53Lr6F+6pXzjnFzflvSL7j7I+7e7+6vuPtfK7rU4kg87lOcgB1zpK7vW8zsDEm/JumcSYZskHSDmS2byfaBlGXq91CaHukoli1P52zMpRMw9iU4T/lJHmudB6ikXjmflJl9TNFfT6TorydcjhlzrS45j49Y+ltFf93+vLs/VcvzgVlK432LJH3U3SeceNrdH1B0xn8pOp/CZL80ArWo2/sWM7tC0RF7b5a0W9KvSjohnne5ovcrvZKul/SwmZ1V6xxAyjL1eyhNj3QcLVueziE8pb98TOdQu5nOU/7XlVrnASqpV84rMrP3S/pk/HCLpDe5e0+VpwAzUa+cf1zS6Yo+93pTjc8FZiuN9y2vuPvGKmP/s2z5whrnASqpS87jJvYdkhZK2iPpEne/3d1fdvdBd3/B3b8k6UpFvzieJOlrtcwBZECmfg9tSmKjqM7di2a2X9KxGnuSlwnik9aVgrCr2tgKyk8aU3UejT1pTK3zABPUMeeVtvdORZf0lKSdij4Tu6/KU4AZqWPOSyds/I6kN09yNH9p2x3xFV4kaa+7f7fGuYAx6pjz8vG1nPjuuBrnASaoY87/m6TSR1a+4O57JqnnGTO7XdERqxeY2Xnu/mSNcwFpGf976KNVxib+eyhNj/RslnSFpNVm1lTlslhrypZrveLE5km2M9fzAJOpR87HMLNfVHRG9AZJL0m61t2nevMMzEY9cl46NPQ98a2aJYr+iihJ90mi6YG5UI+cP1O23DjpqInrq11aFKhFPXJefonbx6cY+5hGP6a7RtFJT4H5YCa/hw5JejaJYvh4S3oeiO87JF1QZdxVZcsP1jjH85JerLCdSq6M73dL2lHjPMBk6pHzV5nZtZL+SVFDd7+iIzyem+n2gGmqa86BlCSec3ffKeln8cOVU5yg9LVly7trmQeooh778/JGylR/gG6e5HlA1j2i0ROYTvp7qJm1SLqk9Bx3H0yiGJoe6fnXsuWKf7UzswZFZ3WWpEOKLl01bfGZ/e+OH64xs0sqjYu/Xuqw3c0VATCHEs952XYuVZT3VkWXM/x5d3+m+rOAOVGP/blNdVP0US5J2ln29atr/F6AydRrf/4v8f0CSddWGff2suUHJh0F1KYeOX++bPmKKcaW/7L4/KSjgIxx96OS/it++HNmNtlHxt6uaH8vSXclVQ9Nj5S4+8OS7o8f3mBmGyoM+7BGD4H7/PjOl5ldbWYe326bZKrPSSqd+fwLZjbmMkDx4y/ED4fi8cCcqFfOzWytpHsU/WWmR9J17v7YXHwPwFTquD8HUlPn9y2ls/7/hZktGD/AzP6HpKvjh/e4O+ciw5yoU87/S9GVWSTpA2ZW8epDZvZGSW+LH+6W9MT0vxMgWWb27rKc3zzJsD+P75sk/aWZjfnYopktkfRn8cNDkv4ukWLFOT3SdqOiQ+LaJd1rZp9U1C1uV3SJqvfF47ZKunUmE7j7VjP7jKTfk7Re0oNm9meSnlN0aOhHJZ0fD/+MuyfyOSoELdGcm9lrFZ3Ff1H8pd+XdNjMzq7ytL3uvrfWuYAqEt+fAxlQj/ctPzOzP5T0aUWXon04ft/ylKK/Br5d0gfi4Uck/fbMvhVgUonm3N0PmdmfSvqEpC5JPzSzL0j6tqSDko6X9BZJv6HRP1D/nruPzPg7AsqY2eWSVpd9aUnZ8moze3f5eHe/bSbzuPt3zewbiv7d/KKkb5vZ5xSdfuEcRVemOzke/lF3PziTeaaDpkeK3H2jmb1D0u2K/iP/ZIVhWxX91fpohXXT9XFJSyX9uqIGxzcqjPl7Rb8sAnOqDjm/QlG+Sz47jefcIunmGcwFVFTH/TmQmnrl3N0/Y2bHKPrDzOmSvlJh2F5Jb+WPNZhrdcr5H0s6RlGDpVPSx+LbeIOS/pe73z7DeYBK3ivpXZOsuyy+lbttFnP9uqJ/R2+SdE18Kzci6Y/c/W9nMceU+HhLytz9m5LOVfSL2lZFh7sdUnRZn49KOt/dt81yjhF3v0HSdYrOefCiohPLvBg/fpO7v5cOMpJSj5wDaSPnCEG9cu7uH1P0xvsfFJ1gvV/R+ZoekfQHkk5z94dmOw9QSdI598hvS7pQ0l9LelrSUUUfST+s6KotfyHpbHf/80k3BGScu/e5+3WSfkXR0Ux7Ff0eukvS/yvpcne/Oek6jHNWAgAAAACAPOJIDwAAAAAAkEs0PQAAAAAAQC7R9AAAAAAAALlE0wMAAAAAAOQSTQ8AAAAAAJBLND0AAAAAAEAu0fQAAAAAAAC5RNMDAAAAAADkEk0PAAAAAACQSzQ9AAAAAABALtH0AAAAAAAAuUTTAwAAAAAA5BJNDwAAAAAAkEs0PQAAAAAAQC7R9AAAAAAAAGUoXpgAAAbsSURBVLlE0wMAAAAAAOQSTQ8AAAAAAJBLND0AAADqyMxWmpmPu32/wribK4x7d/0rBgBg/qLpAQAA5sQkv6SX30bM7KiZ7TSze83sf5nZirTrBgAA+UXTAwAA1ItJ6pR0sqTXS/oTST81s4+kWhUAAMgtmh4AACBNrZI+bWa/lnYhAAAgf5rSLgAAAOTabkn/HC8vlrRe0pkVxt0k6ev1KgoAAISBpgcAAEjSNnf/YOmBmZmkv5T0gXHjVpnZCnffWdfqAABArtH0AAAAdePubmZ/rolND0k6UVLFpoeZdUp6t6Q3SFor6dh41V5JP5J0p6S73d2nqsHMuiT9qqLziqyVtERSs6SXJe2SdJ+ke9z9h+Oe91pJVyo6WmWtpOMkHSNpoaSipAOSNkn6jqR/cPf9U9UCAACSRdMDAADU24uTfP1QpS+a2fWSvqTo4zHjrYxv10v6kZn9d3d/YbKJzew9kj6rqFEx3snx7TJJvxJvt9yfSfqlSTbdqdGTtF4n6SYze6+7/8tktQAAgORxIlMAAFBvr6nwtUFJO8Z/0cw+KOkOVW54jHeJosbHiZVWmtkfSfqKKjc85toiSXeY2YY6zAUAACbBkR4AAKBuzKxB0u9WWHW7uxfHjb1I/397dxNiVRnHcfz718koxRAqCyUDzSYjoyJbZGFm1MYCi4pcBIkuApEoqxmipI1CL4a1SCKoFoEQWi5aFL04ZW8oQpmZmr3SIhDLKFHSf4tzB84cj87cmDtDh+8HLtzzvPzPmd3Mb57nOfBMzdidwDaKLSnzgCmlvikUB6LeVKm1EHisptYx4ENgLzAOuBy4cpAf4wdgH3Cg9QmKrTnXUmx56XcaxWt55w9ST5IkdYihhyRJ6qQZEfFc6/sk4GrgksqY/cDjNXNXceKq1OWZ+UL/RUScAWwCbi6NWRAR12dmX6ltdU39PcCtmfltuTEiLgKW1YxfBzySmd/V9BER44F3gfLqjnkRMSkzD9bNkSRJnWXoIUmSOmkKsOIkfceBjcCKzBxwzkdETKSyWgP4ohx4AGTm4Yh4koGhB8AdQF+rVjdwac29F1UDj1bNvcDKmvb+ehMoVnV0UxyoOh4Y2xo2tjItKA49/aBaT5IkdZ6hhyRJGi07gXXVwKPlKk78PWVORAz6dpaW8mqLa2r6P87Mr4dYC4CIOJdixchi4PQ2pp7dzn0kSdLw8SBTSZI0WmYD70fEXTV959S0teO80vfJNf272ykWEZOArcB9tBd4AJzZ5nhJkjRMDD0kSVInbcnMoPjDfy7waaW/C3g5ImYM830nDHO9XuC/PmMM54NIkqShc3uLJEnquMw8DGyNiFuAL4Fppe7xwBqKczj6/VZTZhfFQaFDcXiQWt1DrNPvtpq2VyjeLrM/M/8GiIjVwKNt1pYkSR1i6CFJkkZMZh6KiB7g9UrX7RFxRWbuaF3voHidbPlg0C7ggcwc9FyPiCjP+7xmyNyImJWZu4b46BdUrg8BSzLzeKW97vwQSZI0StzeIkmSRtoGYF9Ne2//l8z8A3iv0j8TWN96NewJImJqRNwfEduB60q1vgGqh5aOATZFxMU1daZFxJpK89HK9QRgemlORMSDwA11zyZJkkaHKz0kSdKIyszjEfEUsL7StSgiujOz/5DRJ4AFDPwnzVLgzojoA35t9U2meCXtdE6uF3ir0jYT2BkRW4A9wDhgFjAH+IWB21S2A/NK12OAbRHxNvBXa85lp7i/JEkaBYYekiRpNLwKrALOL7WNAXqAewEy87OIeAh4tjL3LGBhOzfLzM2t8zZ6Kl1dwI2tz6k8z8DQA2AicHfp+h+gD5jfzrNJkqTOcXuLJEkacZl5BFhb03VPRFxYGreWIlg40Eb5ryhWgVTv2QssA/5s51lbczcCT59iyFFgCfBRu7UlSVLnGHpIkqTR8iLwe6WtC3i43JCZGygOEl0KvAF8TxFcHKM4UHQ38CawEpidmbMzc0/dDTPzJWAqsBzYDPxEsT3lCPAz8AmwGlhcM3clxQqTd4CDrTk/UqxamZOZr7X100uSpI6LIRyALkmSJEmS9L/jSg9JkiRJktRIhh6SJEmSJKmRDD0kSZIkSVIjGXpIkiRJkqRGMvSQJEmSJEmNZOghSZIkSZIaydBDkiRJkiQ1kqGHJEmSJElqJEMPSZIkSZLUSIYekiRJkiSpkQw9JEmSJElSIxl6SJIkSZKkRjL0kCRJkiRJjWToIUmSJEmSGsnQQ5IkSZIkNZKhhyRJkiRJaiRDD0mSJEmS1EiGHpIkSZIkqZEMPSRJkiRJUiMZekiSJEmSpEYy9JAkSZIkSY1k6CFJkiRJkhrJ0EOSJEmSJDWSoYckSZIkSWqkfwF1WUuKKGfnVgAAAABJRU5ErkJggg==\n",
      "text/plain": [
       "<Figure size 1200x740 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "from matplotlib import pyplot as plt\n",
    "\n",
    "ps, rs, ths = ([], [], [])\n",
    "th = np.max(pred_es)\n",
    "while th >= 0.0:\n",
    "    p, r = pr_at_th(th)\n",
    "    ps.append(p)\n",
    "    rs.append(r)\n",
    "    ths.append(th)\n",
    "    th -= 0.0005\n",
    "    \n",
    "from sklearn import metrics\n",
    "\n",
    "print(f'AUC: {metrics.auc(rs, ps)}, max R: {max(rs)}, max P: {max(ps)}')\n",
    "    \n",
    "i = len(rs) - 1\n",
    "while rs[i] == 1.0:\n",
    "    i -= 1\n",
    "i += 1\n",
    "print(f'100% recall at: {int(ps[i] * 100)}%, threshold: {ths[i]}')\n",
    "\n",
    "fig, ax = plt.subplots(figsize=(6, 3.7), dpi=200)\n",
    "\n",
    "ax.spines['top'].set_color('#808080')\n",
    "ax.spines['right'].set_color('#808080')\n",
    "ax.spines['left'].set_color('#808080')\n",
    "ax.spines['bottom'].set_color('#808080')\n",
    "ax.tick_params(direction='in', color='#808080')\n",
    "\n",
    "plt.grid(color='#c0c0c0', linestyle='--', linewidth=0.5)\n",
    "\n",
    "plt.ylabel('Precision', fontweight='bold')\n",
    "plt.xlabel('Recall', fontweight='bold')\n",
    "\n",
    "plt.xlim((0.0, 1.0))\n",
    "plt.ylim((0.0, 1.0))\n",
    "\n",
    "_ = plt.plot(rs, ps)"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.7.6"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}
